#include"dao_QtNetwork.h"

DaoBase* DaoQt_Get_Wrapper( const QObject *object )
{
  DaoQtObject *user_data = (DaoQtObject*) ((QObject*)object)->userData(0);
  DaoBase *dbase = NULL;
  // no need to map to DaoObject, because it will always be mapped back to
  // DaoCData when passed to Dao codes.
  if( user_data ) dbase = (DaoBase*) user_data->cdata;
  return dbase;
}

DaoMethod* Dao_Get_Object_Method( DaoCData *cd, DValue *obj, const char *name )
{
  DaoMethod *meth;
  if( cd == NULL ) return NULL;
  obj->v.object = DaoCData_GetObject( cd );
  if( obj->v.object == NULL ) return NULL;
  obj->t = DAO_OBJECT;
  meth = DaoObject_GetMethod( obj->v.object, name );
  if( meth == NULL ) return NULL;
  if( meth->type != DAO_METAROUTINE && meth->type != DAO_ROUTINE ) return NULL;
  return meth;
}

static QAbstractFileEngine* Function_101d8( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QAbstractFileEngine* _fileEngine = NULL;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QAbstractFileEngine_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QAbstractFileEngine_Typer ) ){
    _fileEngine = (QAbstractFileEngine*) DValue_CastCData( &_res, dao_QAbstractFileEngine_Typer );
  }

EndCall:
  return _fileEngine;
}

static QAbstractFileEngine* Function_10058( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &fileName )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QAbstractFileEngine* _create = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) fileName.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QAbstractFileEngine_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QAbstractFileEngine_Typer ) ){
    _create = (QAbstractFileEngine*) DValue_CastCData( &_res, dao_QAbstractFileEngine_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _create;
}

static QAbstractFileEngine::FileFlags Function_10047( int *_cs, DaoMethod *_ro, DValue *_ob, QAbstractFileEngine::FileFlags type )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QAbstractFileEngine::FileFlags _fileFlags= (QAbstractFileEngine::FileFlags)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) type );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _fileFlags= (QAbstractFileEngine::FileFlags) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _fileFlags;
}

static QAbstractFileEngine::Iterator* Function_1004f( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QAbstractFileEngine::Iterator* _endEntryList = 0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QAbstractFileEngine_Iterator_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QAbstractFileEngine_Iterator_Typer ) ){
    _endEntryList = (QAbstractFileEngine::Iterator*) DValue_CastCData( &_res, dao_QAbstractFileEngine_Iterator_Typer );
  }

EndCall:
  return _endEntryList;
}

static QAbstractFileEngine::Iterator* Function_1004e( int *_cs, DaoMethod *_ro, DValue *_ob, QDir::Filters filters, const QStringList &filterNames )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QAbstractFileEngine::Iterator* _beginEntryList = 0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) filters );
  _dp[1] = DValue_WrapCData( dao_QStringList_Typer, (void*) & filterNames );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QAbstractFileEngine_Iterator_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QAbstractFileEngine_Iterator_Typer ) ){
    _beginEntryList = (QAbstractFileEngine::Iterator*) DValue_CastCData( &_res, dao_QAbstractFileEngine_Iterator_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _beginEntryList;
}

static QByteArray Function_100f9( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QByteArray _toLower;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QByteArray_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QByteArray_Typer ) ){
    _toLower = *(QByteArray*) DValue_CastCData( &_res, dao_QByteArray_Typer );
  }

EndCall:
  return _toLower;
}

static QByteArray Function_104c1( int *_cs, DaoMethod *_ro, DValue *_ob, const QChar* in, int length, QTextCodec::ConverterState* state )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QByteArray _convertFromUnicode;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( in->digitValue() );
  _dp[1] = DValue_NewInteger( (int) length );
  _dp[2] = DValue_WrapCData( dao_QTextCodec_ConverterState_Typer, (void*) state );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _convertFromUnicode= DValue_GetMBString( & _res );

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _convertFromUnicode;
}

static QDateTime Function_1004b( int *_cs, DaoMethod *_ro, DValue *_ob, int time )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QDateTime _fileTime;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) time );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QDateTime_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QDateTime_Typer ) ){
    _fileTime = *(QDateTime*) DValue_CastCData( &_res, dao_QDateTime_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _fileTime;
}

static QFileInfo Function_1005e( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QFileInfo _currentFileInfo;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QFileInfo_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QFileInfo_Typer ) ){
    _currentFileInfo = *(QFileInfo*) DValue_CastCData( &_res, dao_QFileInfo_Typer );
  }

EndCall:
  return _currentFileInfo;
}

static QIODevice* Function_10090( int *_cs, DaoMethod *_ro, DValue *_ob, const QNetworkCacheMetaData &metaData )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QIODevice* _prepare = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QNetworkCacheMetaData_Typer, (void*) & metaData );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QIODevice_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QIODevice_Typer ) ){
    _prepare = (QIODevice*) DValue_CastCData( &_res, dao_QIODevice_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _prepare;
}

static QIODevice* Function_1008e( int *_cs, DaoMethod *_ro, DValue *_ob, const QUrl &url )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QIODevice* _data = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QUrl_Typer, (void*) & url );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QIODevice_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QIODevice_Typer ) ){
    _data = (QIODevice*) DValue_CastCData( &_res, dao_QIODevice_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _data;
}

static QLocalSocket* Function_1027d( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QLocalSocket* _nextPendingConnection = NULL;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QLocalSocket_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QLocalSocket_Typer ) ){
    _nextPendingConnection = (QLocalSocket*) DValue_CastCData( &_res, dao_QLocalSocket_Typer );
  }

EndCall:
  return _nextPendingConnection;
}

static QLocale Function_103a2( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QLocale _locale;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QLocale_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QLocale_Typer ) ){
    _locale = *(QLocale*) DValue_CastCData( &_res, dao_QLocale_Typer );
  }

EndCall:
  return _locale;
}

static QMimeData* Function_10078( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndexList &indexes )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QMimeData* _mimeData = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndexList_Typer, (void*) & indexes );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QMimeData_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QMimeData_Typer ) ){
    _mimeData = (QMimeData*) DValue_CastCData( &_res, dao_QMimeData_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _mimeData;
}

static QModelIndex Function_1006f( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &child )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QModelIndex _parent;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & child );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QModelIndex_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QModelIndex_Typer ) ){
    _parent = *(QModelIndex*) DValue_CastCData( &_res, dao_QModelIndex_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _parent;
}

static QModelIndex Function_1006e( int *_cs, DaoMethod *_ro, DValue *_ob, int row, int column, const QModelIndex &parent )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QModelIndex _index;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) row );
  _dp[1] = DValue_NewInteger( (int) column );
  _dp[2] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & parent );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QModelIndex_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QModelIndex_Typer ) ){
    _index = *(QModelIndex*) DValue_CastCData( &_res, dao_QModelIndex_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _index;
}

static QModelIndexList Function_10081( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[5] = { _dao_nil, _dao_nil, _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[5] = { _dp+0, _dp+1, _dp+2, _dp+3, _dp+4 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QModelIndexList _match;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & start );
  _dp[1] = DValue_NewInteger( (int) role );
  _dp[2] = DValue_WrapCData( dao_QVariant_Typer, (void*) & value );
  _dp[3] = DValue_NewInteger( (int) hits );
  _dp[4] = DValue_NewInteger( (int) flags );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 5 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 5 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QModelIndexList_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QModelIndexList_Typer ) ){
    _match = *(QModelIndexList*) DValue_CastCData( &_res, dao_QModelIndexList_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 5 );
  return _match;
}

static QNetworkCacheMetaData Function_1008c( int *_cs, DaoMethod *_ro, DValue *_ob, const QUrl &url )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QNetworkCacheMetaData _metaData;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QUrl_Typer, (void*) & url );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QNetworkCacheMetaData_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QNetworkCacheMetaData_Typer ) ){
    _metaData = *(QNetworkCacheMetaData*) DValue_CastCData( &_res, dao_QNetworkCacheMetaData_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _metaData;
}

static QNetworkReply* Function_102fb( int *_cs, DaoMethod *_ro, DValue *_ob, int op, const QNetworkRequest &request, QIODevice* outgoingData )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QNetworkReply* _createRequest = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) op );
  _dp[1] = DValue_WrapCData( dao_QNetworkRequest_Typer, (void*) & request );
  _dp[2] = DValue_WrapCData( dao_QIODevice_Typer, (void*) outgoingData );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QNetworkReply_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QNetworkReply_Typer ) ){
    _createRequest = (QNetworkReply*) DValue_CastCData( &_res, dao_QNetworkReply_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _createRequest;
}

static QSize Function_10082( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &index )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QSize _span;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & index );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QSize_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QSize_Typer ) ){
    _span = *(QSize*) DValue_CastCData( &_res, dao_QSize_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _span;
}

static QString Function_1005b( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _next;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _next= DValue_GetMBString( & _res );

EndCall:
  return _next;
}

static QString Function_10016( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _objectName;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _objectName= DValue_GetMBString( & _res );

EndCall:
  return _objectName;
}

static QString Function_10196( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &pathName )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _toNativeSeparators;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) pathName.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _toNativeSeparators= DValue_GetMBString( & _res );

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _toNativeSeparators;
}

static QString Function_10587( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &publicId, const QString &systemId )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _resolveEntity;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) publicId.toLocal8Bit().data(), 0 );
  _dp[1] = DValue_NewMBString( (char*) systemId.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _resolveEntity= DValue_GetMBString( & _res );

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _resolveEntity;
}

static QString Function_1050a( int *_cs, DaoMethod *_ro, DValue *_ob, const char* context, const char* sourceText, const char* disambiguation )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _translate;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) context, strlen( (char*)context ) );
  _dp[1] = DValue_NewMBString( (char*) sourceText, strlen( (char*)sourceText ) );
  _dp[2] = DValue_NewMBString( (char*) disambiguation, strlen( (char*)disambiguation ) );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _translate= DValue_GetMBString( & _res );

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _translate;
}

static QString Function_104c0( int *_cs, DaoMethod *_ro, DValue *_ob, const char* in, int length, QTextCodec::ConverterState* state )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _convertToUnicode;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) in, strlen( (char*)in ) );
  _dp[1] = DValue_NewInteger( (int) length );
  _dp[2] = DValue_WrapCData( dao_QTextCodec_ConverterState_Typer, (void*) state );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _convertToUnicode= DValue_GetMBString( & _res );

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _convertToUnicode;
}

static QString Function_10049( int *_cs, DaoMethod *_ro, DValue *_ob, int file )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QString _fileName;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) file );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_STRING ) _fileName= DValue_GetMBString( & _res );

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _fileName;
}

static QStringList Function_1005c( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QStringList _nameFilters;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QStringList_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QStringList_Typer ) ){
    _nameFilters = *(QStringList*) DValue_CastCData( &_res, dao_QStringList_Typer );
  }

EndCall:
  return _nameFilters;
}

static QStringList Function_10046( int *_cs, DaoMethod *_ro, DValue *_ob, QDir::Filters filters, const QStringList &filterNames )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QStringList _entryList;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) filters );
  _dp[1] = DValue_WrapCData( dao_QStringList_Typer, (void*) & filterNames );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QStringList_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QStringList_Typer ) ){
    _entryList = *(QStringList*) DValue_CastCData( &_res, dao_QStringList_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _entryList;
}

static QTcpSocket* Function_104b1( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QTcpSocket* _nextPendingConnection = NULL;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QTcpSocket_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QTcpSocket_Typer ) ){
    _nextPendingConnection = (QTcpSocket*) DValue_CastCData( &_res, dao_QTcpSocket_Typer );
  }

EndCall:
  return _nextPendingConnection;
}

static QTextCodec* Function_104c3( int *_cs, DaoMethod *_ro, DValue *_ob, const QByteArray &name )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QTextCodec* _codecForName = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) name.data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QTextCodec_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QTextCodec_Typer ) ){
    _codecForName = (QTextCodec*) DValue_CastCData( &_res, dao_QTextCodec_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _codecForName;
}

static QTextCodec* Function_104d2( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &key )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QTextCodec* _create = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) key.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QTextCodec_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QTextCodec_Typer ) ){
    _create = (QTextCodec*) DValue_CastCData( &_res, dao_QTextCodec_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _create;
}

static QTextCodec* Function_104c5( int *_cs, DaoMethod *_ro, DValue *_ob, int mib )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QTextCodec* _codecForMib = NULL;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) mib );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QTextCodec_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QTextCodec_Typer ) ){
    _codecForMib = (QTextCodec*) DValue_CastCData( &_res, dao_QTextCodec_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _codecForMib;
}

static QVariant Function_10072( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &index, int role )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QVariant _data;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & index );
  _dp[1] = DValue_NewInteger( (int) role );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QVariant_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QVariant_Typer ) ){
    _data = *(QVariant*) DValue_CastCData( &_res, dao_QVariant_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _data;
}

static QVariant Function_102e7( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &mimetype, QVariant::Type preferredType )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QVariant _retrieveData;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) mimetype.toLocal8Bit().data(), 0 );
  _dp[1] = DValue_NewInteger( (int) preferredType );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QVariant_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QVariant_Typer ) ){
    _retrieveData = *(QVariant*) DValue_CastCData( &_res, dao_QVariant_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _retrieveData;
}

static QVariant Function_10367( int *_cs, DaoMethod *_ro, DValue *_ob, const QVariant &from, const QVariant &to, qreal progress )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QVariant _interpolated;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QVariant_Typer, (void*) & from );
  _dp[1] = DValue_WrapCData( dao_QVariant_Typer, (void*) & to );
  _dp[2] = DValue_NewDouble( (double) progress );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QVariant_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QVariant_Typer ) ){
    _interpolated = *(QVariant*) DValue_CastCData( &_res, dao_QVariant_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _interpolated;
}

static QVariant Function_10059( int *_cs, DaoMethod *_ro, DValue *_ob, int type )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QVariant _entryInfo;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) type );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QVariant_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QVariant_Typer ) ){
    _entryInfo = *(QVariant*) DValue_CastCData( &_res, dao_QVariant_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _entryInfo;
}

static QVariant Function_104a9( int *_cs, DaoMethod *_ro, DValue *_ob, int type, QVariant in )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QVariant _query;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) type );
  _dp[1] = DValue_WrapCData( dao_QVariant_Typer, (void*) & in );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QVariant_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QVariant_Typer ) ){
    _query = *(QVariant*) DValue_CastCData( &_res, dao_QVariant_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _query;
}

static QVariant Function_10074( int *_cs, DaoMethod *_ro, DValue *_ob, int section, Qt::Orientation orientation, int role )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QVariant _headerData;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) section );
  _dp[1] = DValue_NewInteger( (int) orientation );
  _dp[2] = DValue_NewInteger( (int) role );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_OBJECT && (_cd = DaoObject_MapCData( _res.v.object, dao_QVariant_Typer ) ) ){
    _res.t = DAO_CDATA;
    _res.v.cdata = _cd;
  }
  if( _res.t == DAO_CDATA && DaoCData_IsType( _res.v.cdata, dao_QVariant_Typer ) ){
    _headerData = *(QVariant*) DValue_CastCData( &_res, dao_QVariant_Typer );
  }

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _headerData;
}

static Qt::DropActions Function_1007a( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  Qt::DropActions _supportedDropActions= (Qt::DropActions)0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _supportedDropActions= (Qt::DropActions) _res.v.i;

EndCall:
  return _supportedDropActions;
}

static Qt::ItemFlags Function_1007f( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &index )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  Qt::ItemFlags _flags= (Qt::ItemFlags)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & index );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _flags= (Qt::ItemFlags) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _flags;
}

static bool Function_10009( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _blockSizeMaxed= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _blockSizeMaxed= (bool) _res.v.i;

EndCall:
  return _blockSizeMaxed;
}

static bool Function_10018( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _isWidgetType= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _isWidgetType= (bool) _res.v.i;

EndCall:
  return _isWidgetType;
}

static bool Function_10012( int *_cs, DaoMethod *_ro, DValue *_ob, QEvent* _cp0 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _event= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QEvent_Typer, (void*) _cp0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _event= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _event;
}

static bool Function_10154( int *_cs, DaoMethod *_ro, DValue *_ob, QEvent* _cp0, QObject* receiver, QPostEventList* _cp2 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _compressEvent= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QEvent_Typer, (void*) _cp0 );
  _dp[1] = DValue_WrapCData( dao_QObject_Typer, (void*) receiver );
  _dp[2] = DValue_WrapCData( dao_QPostEventList_Typer, (void*) _cp2 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _compressEvent= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _compressEvent;
}

static bool Function_10035( int *_cs, DaoMethod *_ro, DValue *_ob, QEventLoop::ProcessEventsFlags flags )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _processEvents= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) flags );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _processEvents= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _processEvents;
}

static bool Function_10041( int *_cs, DaoMethod *_ro, DValue *_ob, QIODevice::OpenMode openMode )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _open= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) openMode );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _open= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _open;
}

static bool Function_1003a( int *_cs, DaoMethod *_ro, DValue *_ob, QObject* object )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _unregisterTimers= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QObject_Typer, (void*) object );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _unregisterTimers= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _unregisterTimers;
}

static bool Function_10013( int *_cs, DaoMethod *_ro, DValue *_ob, QObject* _cp0, QEvent* _cp1 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _eventFilter= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QObject_Typer, (void*) _cp0 );
  _dp[1] = DValue_WrapCData( dao_QEvent_Typer, (void*) _cp1 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _eventFilter= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _eventFilter;
}

static bool Function_10079( int *_cs, DaoMethod *_ro, DValue *_ob, const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex &parent )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[5] = { _dao_nil, _dao_nil, _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[5] = { _dp+0, _dp+1, _dp+2, _dp+3, _dp+4 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _dropMimeData= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QMimeData_Typer, (void*) data );
  _dp[1] = DValue_NewInteger( (int) action );
  _dp[2] = DValue_NewInteger( (int) row );
  _dp[3] = DValue_NewInteger( (int) column );
  _dp[4] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & parent );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 5 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 5 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _dropMimeData= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 5 );
  return _dropMimeData;
}

static bool Function_10071( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &parent )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _hasChildren= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & parent );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _hasChildren= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _hasChildren;
}

static bool Function_10073( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &index, const QVariant &value, int role )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _setData= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & index );
  _dp[1] = DValue_WrapCData( dao_QVariant_Typer, (void*) & value );
  _dp[2] = DValue_NewInteger( (int) role );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _setData= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _setData;
}

static bool Function_10044( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &newName )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _copy= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) newName.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _copy= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _copy;
}

static bool Function_1019e( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &dirName )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _mkdir= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) dirName.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _mkdir= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _mkdir;
}

static bool Function_10045( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &dirName, bool createParentDirectories )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _mkdir= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) dirName.toLocal8Bit().data(), 0 );
  _dp[1] = DValue_NewInteger( (int) createParentDirectories );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _mkdir= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _mkdir;
}

static bool Function_10236( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &line, int number )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _parseLine= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) line.toLocal8Bit().data(), 0 );
  _dp[1] = DValue_NewInteger( (int) number );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _parseLine= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _parseLine;
}

static bool Function_1008f( int *_cs, DaoMethod *_ro, DValue *_ob, const QUrl &url )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _remove= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QUrl_Typer, (void*) & url );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _remove= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _remove;
}

static bool Function_10039( int *_cs, DaoMethod *_ro, DValue *_ob, int timerId )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _unregisterTimer= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) timerId );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _unregisterTimer= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _unregisterTimer;
}

static bool Function_10054( int *_cs, DaoMethod *_ro, DValue *_ob, int extension )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _supportsExtension= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) extension );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _supportsExtension= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _supportsExtension;
}

static bool Function_10075( int *_cs, DaoMethod *_ro, DValue *_ob, int section, Qt::Orientation orientation, const QVariant &value, int role )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[4] = { _dao_nil, _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[4] = { _dp+0, _dp+1, _dp+2, _dp+3 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _setHeaderData= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) section );
  _dp[1] = DValue_NewInteger( (int) orientation );
  _dp[2] = DValue_WrapCData( dao_QVariant_Typer, (void*) & value );
  _dp[3] = DValue_NewInteger( (int) role );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 4 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 4 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _setHeaderData= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 4 );
  return _setHeaderData;
}

static bool Function_10053( int *_cs, DaoMethod *_ro, DValue *_ob, int extension, const QAbstractFileEngine::ExtensionOption* option, QAbstractFileEngine::ExtensionReturn* output )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _extension= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) extension );
  _dp[1] = DValue_WrapCData( dao_QAbstractFileEngine_ExtensionOption_Typer, (void*) option );
  _dp[2] = DValue_WrapCData( dao_QAbstractFileEngine_ExtensionReturn_Typer, (void*) output );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _extension= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _extension;
}

static bool Function_1007c( int *_cs, DaoMethod *_ro, DValue *_ob, int row, int count, const QModelIndex &parent )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _insertRows= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) row );
  _dp[1] = DValue_NewInteger( (int) count );
  _dp[2] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & parent );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _insertRows= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 3 );
  return _insertRows;
}

static bool Function_10043( int *_cs, DaoMethod *_ro, DValue *_ob, qint64 pos )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _seek= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewDouble( (double) pos );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _seek= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _seek;
}

static bool Function_10048( int *_cs, DaoMethod *_ro, DValue *_ob, uint perms )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  bool _setPermissions= (bool)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) perms );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _setPermissions= (bool) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _setPermissions;
}

static QAbstractAnimation::State Function_1002d( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  QAbstractAnimation::State _state= (QAbstractAnimation::State)0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _state= (QAbstractAnimation::State) _res.v.i;

EndCall:
  return _state;
}

static int Function_10070( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &parent )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  int _rowCount= (int)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & parent );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _rowCount= (int) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _rowCount;
}

static qint64 Function_10160( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  qint64 _applicationPid= (qint64)0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_DOUBLE ) _applicationPid= (qint64) _res.v.d;

EndCall:
  return _applicationPid;
}

static qint64 Function_10042( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  qint64 _size= (qint64)0;
  if( _ro == NULL ) goto EndCall;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_DOUBLE ) _size= (qint64) _res.v.d;

EndCall:
  return _size;
}

static qint64 Function_10050( int *_cs, DaoMethod *_ro, DValue *_ob, char* data, qint64 maxlen )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  qint64 _read= (qint64)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) data, strlen( (char*)data ) );
  _dp[1] = DValue_NewDouble( (double) maxlen );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_DOUBLE ) _read= (qint64) _res.v.d;

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _read;
}

static qint64 Function_10051( int *_cs, DaoMethod *_ro, DValue *_ob, const char* data, qint64 len )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  qint64 _write= (qint64)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewMBString( (char*) data, strlen( (char*)data ) );
  _dp[1] = DValue_NewDouble( (double) len );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_DOUBLE ) _write= (qint64) _res.v.d;

EndCall:
  DValue_ClearAll( _dp, 2 );
  return _write;
}

static qreal Function_10502( int *_cs, DaoMethod *_ro, DValue *_ob, int msec )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  qreal _valueForTime= (qreal)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) msec );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_DOUBLE ) _valueForTime= (qreal) _res.v.d;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _valueForTime;
}

static uint Function_1004a( int *_cs, DaoMethod *_ro, DValue *_ob, int _cp0 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  DValue _res;
  DaoCData *_cd;
  DaoVmProcess *_vmp;
  uint _ownerId= (uint)0;
  if( _ro == NULL ) goto EndCall;
  _dp[0] = DValue_NewInteger( (int) _cp0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) goto EndCall;
  _vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  if( (*_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 )) ==0 ) goto EndCall;
  _res = DaoVmProcess_GetReturned( _vmp );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  if( _res.t == DAO_INTEGER ) _ownerId= (uint) _res.v.i;

EndCall:
  DValue_ClearAll( _dp, 1 );
  return _ownerId;
}

static void Function_10007( int *_cs, DaoMethod *_ro, DValue *_ob )
{
  if( _ro == NULL ) return;
  _ro = DaoMethod_Resolve( _ro, _ob, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, NULL, 0 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
}

static void Function_1002b( int *_cs, DaoMethod *_ro, DValue *_ob, QAbstractAnimation::Direction direction )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewInteger( (int) direction );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1002a( int *_cs, DaoMethod *_ro, DValue *_ob, QAbstractAnimation::State newState, QAbstractAnimation::State oldState )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewInteger( (int) newState );
  _dp[1] = DValue_NewInteger( (int) oldState );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 2 );
}

static void Function_1000d( int *_cs, DaoMethod *_ro, DValue *_ob, QChildEvent* _cp0 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QChildEvent_Typer, (void*) _cp0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1000e( int *_cs, DaoMethod *_ro, DValue *_ob, QEvent* _cp0 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QEvent_Typer, (void*) _cp0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_10091( int *_cs, DaoMethod *_ro, DValue *_ob, QIODevice* device )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QIODevice_Typer, (void*) device );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_10036( int *_cs, DaoMethod *_ro, DValue *_ob, QSocketNotifier* notifier )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QSocketNotifier_Typer, (void*) notifier );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1000c( int *_cs, DaoMethod *_ro, DValue *_ob, QTimerEvent* _cp0 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QTimerEvent_Typer, (void*) _cp0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_10030( int *_cs, DaoMethod *_ro, DValue *_ob, bool _cp0 )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewInteger( (int) _cp0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_10311( int *_cs, DaoMethod *_ro, DValue *_ob, const QDateTime &dateTime )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QDateTime_Typer, (void*) & dateTime );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1007e( int *_cs, DaoMethod *_ro, DValue *_ob, const QModelIndex &parent )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QModelIndex_Typer, (void*) & parent );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1008d( int *_cs, DaoMethod *_ro, DValue *_ob, const QNetworkCacheMetaData &metaData )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QNetworkCacheMetaData_Typer, (void*) & metaData );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_10017( int *_cs, DaoMethod *_ro, DValue *_ob, const QString &name )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewMBString( (char*) name.toLocal8Bit().data(), 0 );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_102ec( int *_cs, DaoMethod *_ro, DValue *_ob, const QVariant &image )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_QVariant_Typer, (void*) & image );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1000f( int *_cs, DaoMethod *_ro, DValue *_ob, const char* signal )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewMBString( (char*) signal, strlen( (char*)signal ) );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1001d( int *_cs, DaoMethod *_ro, DValue *_ob, int id )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewInteger( (int) id );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_10080( int *_cs, DaoMethod *_ro, DValue *_ob, int column, Qt::SortOrder order )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[2] = { _dao_nil, _dao_nil };
  DValue *_dp2[2] = { _dp+0, _dp+1 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewInteger( (int) column );
  _dp[1] = DValue_NewInteger( (int) order );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 2 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 2 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 2 );
}

static void Function_10038( int *_cs, DaoMethod *_ro, DValue *_ob, int timerId, int interval, QObject* object )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[3] = { _dao_nil, _dao_nil, _dao_nil };
  DValue *_dp2[3] = { _dp+0, _dp+1, _dp+2 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewInteger( (int) timerId );
  _dp[1] = DValue_NewInteger( (int) interval );
  _dp[2] = DValue_WrapCData( dao_QObject_Typer, (void*) object );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 3 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 3 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 3 );
}

static void Function_1009f( int *_cs, DaoMethod *_ro, DValue *_ob, qint64 bytes )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_NewDouble( (double) bytes );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}

static void Function_1027b( int *_cs, DaoMethod *_ro, DValue *_ob, quintptr socketDescriptor )
{
  const DValue _dao_nil = {0,0,0,0,{0}};
  DValue _dp[1] = { _dao_nil };
  DValue *_dp2[1] = { _dp+0 };
  if( _ro == NULL ) return;
  _dp[0] = DValue_WrapCData( dao_quintptr_Typer, (void*) & socketDescriptor );

  _ro = DaoMethod_Resolve( _ro, _ob, _dp2, 1 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  *_cs = DaoVmProcess_Call( _vmp, _ro, _ob, _dp2, 1 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
  DValue_ClearAll( _dp, 1 );
}













void DAO_DLL_QTNETWORK Dao_QAbstractNetworkCache_InitSS( QAbstractNetworkCache *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QAbstractNetworkCache *linker = new DaoSS_QAbstractNetworkCache();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QAbstractNetworkCache* DAO_DLL_QTNETWORK DaoCxx_QAbstractNetworkCache_New( QAbstractNetworkCachePrivate &dd, QObject* parent )
{
	DaoCxx_QAbstractNetworkCache *self = new DaoCxx_QAbstractNetworkCache( dd, parent );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QAbstractNetworkCache* DAO_DLL_QTNETWORK DaoCxx_QAbstractNetworkCache_New( QObject* parent )
{
	DaoCxx_QAbstractNetworkCache *self = new DaoCxx_QAbstractNetworkCache( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QAbstractNetworkCache::slot_clear12( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_clear12(  );
}
void DaoCxxVirt_QAbstractNetworkCache::DaoInitWrapper( QAbstractNetworkCache *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QAbstractNetworkCache::~DaoCxx_QAbstractNetworkCache()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QAbstractNetworkCache::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QAbstractNetworkCache_Typer, this );
	DaoCxxVirt_QAbstractNetworkCache::DaoInitWrapper( this, cdata );
   DaoSS_QAbstractNetworkCache *linker = new DaoSS_QAbstractNetworkCache();
   setUserData( 0, linker );
   linker->Init( cdata );
}
qint64 DaoCxxVirt_QAbstractNetworkCache::cacheSize( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "cacheSize" );
  qint64 _cacheSize= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _cacheSize;
  return (qint64)Function_10042( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QAbstractNetworkCache::clear( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "clear" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  _ro = DaoMethod_Resolve( _ro, & _obj, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  DaoVmProcess_Call( _vmp, _ro, & _obj, NULL, 0 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
}
QIODevice* DaoCxxVirt_QAbstractNetworkCache::data( int &_cs, const QUrl &url )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "data" );
  QIODevice* _data = NULL;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _data;
  return (QIODevice*)Function_1008e( & _cs, _ro, & _obj, url );
}
void DaoCxxVirt_QAbstractNetworkCache::insert( int &_cs, QIODevice* device )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "insert" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10091( & _cs, _ro, & _obj, device );
}
QNetworkCacheMetaData DaoCxxVirt_QAbstractNetworkCache::metaData( int &_cs, const QUrl &url )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "metaData" );
  QNetworkCacheMetaData _metaData;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _metaData;
  return (QNetworkCacheMetaData)Function_1008c( & _cs, _ro, & _obj, url );
}
QIODevice* DaoCxxVirt_QAbstractNetworkCache::prepare( int &_cs, const QNetworkCacheMetaData &metaData )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "prepare" );
  QIODevice* _prepare = NULL;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _prepare;
  return (QIODevice*)Function_10090( & _cs, _ro, & _obj, metaData );
}
bool DaoCxxVirt_QAbstractNetworkCache::remove( int &_cs, const QUrl &url )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "remove" );
  bool _remove= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _remove;
  return (bool)Function_1008f( & _cs, _ro, & _obj, url );
}
void DaoCxxVirt_QAbstractNetworkCache::updateMetaData( int &_cs, const QNetworkCacheMetaData &metaData )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "updateMetaData" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_1008d( & _cs, _ro, & _obj, metaData );
}
void DaoCxxVirt_QAbstractNetworkCache::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QAbstractNetworkCache::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QAbstractNetworkCache::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QAbstractNetworkCache::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QAbstractNetworkCache::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QAbstractNetworkCache::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QAbstractNetworkCache::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
qint64 DaoCxx_QAbstractNetworkCache::cacheSize(  )const
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::cacheSize( _cs  );
}
void DaoCxx_QAbstractNetworkCache::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QAbstractNetworkCache::clear(  )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::clear( _cs  );
}
void DaoCxx_QAbstractNetworkCache::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
void DaoCxx_QAbstractNetworkCache::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
QIODevice* DaoCxx_QAbstractNetworkCache::data( const QUrl &url )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::data( _cs, url );
}
void DaoCxx_QAbstractNetworkCache::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QAbstractNetworkCache::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QAbstractNetworkCache::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QAbstractNetworkCache::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QAbstractNetworkCache::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
void DaoCxx_QAbstractNetworkCache::insert( QIODevice* device )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::insert( _cs, device );
}
QNetworkCacheMetaData DaoCxx_QAbstractNetworkCache::metaData( const QUrl &url )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::metaData( _cs, url );
}
QIODevice* DaoCxx_QAbstractNetworkCache::prepare( const QNetworkCacheMetaData &metaData )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::prepare( _cs, metaData );
}
bool DaoCxx_QAbstractNetworkCache::remove( const QUrl &url )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::remove( _cs, url );
}
void DaoCxx_QAbstractNetworkCache::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}
void DaoCxx_QAbstractNetworkCache::updateMetaData( const QNetworkCacheMetaData &metaData )
{
  int _cs = 0;
  return DaoCxxVirt_QAbstractNetworkCache::updateMetaData( _cs, metaData );
}


void DAO_DLL_QTNETWORK Dao_QAbstractSocket_InitSS( QAbstractSocket *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QAbstractSocket *linker = new DaoSS_QAbstractSocket();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QAbstractSocket* DAO_DLL_QTNETWORK DaoCxx_QAbstractSocket_New( QAbstractSocket::SocketType socketType, QAbstractSocketPrivate &dd, QObject* parent )
{
	DaoCxx_QAbstractSocket *self = new DaoCxx_QAbstractSocket( socketType, dd, parent );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QAbstractSocket* DAO_DLL_QTNETWORK DaoCxx_QAbstractSocket_New( QAbstractSocket::SocketType socketType, QObject* parent )
{
	DaoCxx_QAbstractSocket *self = new DaoCxx_QAbstractSocket( socketType, parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QAbstractSocket::slot_hostFound629(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_hostFound629( this, "hostFound()", _message );
}
void DaoSS_QAbstractSocket::slot_connected94(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_connected94( this, "connected()", _message );
}
void DaoSS_QAbstractSocket::slot_disconnected23(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_disconnected23( this, "disconnected()", _message );
}
void DaoSS_QAbstractSocket::slot_stateChanged216( QAbstractSocket::SocketState _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_stateChanged216( this, "stateChanged(QAbstractSocket::SocketState)", _message );
}
void DaoSS_QAbstractSocket::slot_error667( QAbstractSocket::SocketError _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_error667( this, "error(QAbstractSocket::SocketError)", _message );
}
void DaoCxxVirt_QAbstractSocket::DaoInitWrapper( QAbstractSocket *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QIODevice::DaoInitWrapper( s, d );
}
DaoCxx_QAbstractSocket::~DaoCxx_QAbstractSocket()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QAbstractSocket::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QAbstractSocket_Typer, this );
	DaoCxxVirt_QAbstractSocket::DaoInitWrapper( this, cdata );
   DaoSS_QAbstractSocket *linker = new DaoSS_QAbstractSocket();
   setUserData( 0, linker );
   linker->Init( cdata );
}
bool DaoCxxVirt_QAbstractSocket::open( int &_cs, QIODevice::OpenMode mode )
{
  return DaoCxxVirt_QIODevice::open( _cs, mode );
}
qint64 DaoCxxVirt_QAbstractSocket::pos( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::pos( _cs  );
}
bool DaoCxxVirt_QAbstractSocket::reset( int &_cs  )
{
  return DaoCxxVirt_QIODevice::reset( _cs  );
}
bool DaoCxxVirt_QAbstractSocket::seek( int &_cs, qint64 pos )
{
  return DaoCxxVirt_QIODevice::seek( _cs, pos );
}
qint64 DaoCxxVirt_QAbstractSocket::size( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::size( _cs  );
}
bool DaoCxx_QAbstractSocket::open( QIODevice::OpenMode mode )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "open" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _open = DaoCxxVirt_QAbstractSocket::open( _cs, mode );
	if( _cs ) return _open;
  }
  return QIODevice::open( mode );
}
qint64 DaoCxx_QAbstractSocket::pos(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "pos" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _pos = DaoCxxVirt_QAbstractSocket::pos( _cs  );
	if( _cs ) return _pos;
  }
  return QIODevice::pos(  );
}
bool DaoCxx_QAbstractSocket::reset(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "reset" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _reset = DaoCxxVirt_QAbstractSocket::reset( _cs  );
	if( _cs ) return _reset;
  }
  return QIODevice::reset(  );
}
bool DaoCxx_QAbstractSocket::seek( qint64 pos )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "seek" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _seek = DaoCxxVirt_QAbstractSocket::seek( _cs, pos );
	if( _cs ) return _seek;
  }
  return QIODevice::seek( pos );
}
qint64 DaoCxx_QAbstractSocket::size(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "size" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _size = DaoCxxVirt_QAbstractSocket::size( _cs  );
	if( _cs ) return _size;
  }
  return QIODevice::size(  );
}
bool DaoCxx_QAbstractSocket::atEnd(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "atEnd" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _atEnd = DaoCxxVirt_QIODevice::atEnd( _cs  );
	if( _cs ) return _atEnd;
  }
  return QAbstractSocket::atEnd(  );
}
qint64 DaoCxx_QAbstractSocket::bytesAvailable(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesAvailable" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesAvailable = DaoCxxVirt_QIODevice::bytesAvailable( _cs  );
	if( _cs ) return _bytesAvailable;
  }
  return QAbstractSocket::bytesAvailable(  );
}
qint64 DaoCxx_QAbstractSocket::bytesToWrite(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesToWrite" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesToWrite = DaoCxxVirt_QIODevice::bytesToWrite( _cs  );
	if( _cs ) return _bytesToWrite;
  }
  return QAbstractSocket::bytesToWrite(  );
}
bool DaoCxx_QAbstractSocket::canReadLine(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "canReadLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _canReadLine = DaoCxxVirt_QIODevice::canReadLine( _cs  );
	if( _cs ) return _canReadLine;
  }
  return QAbstractSocket::canReadLine(  );
}
void DaoCxx_QAbstractSocket::close(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "close" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QIODevice::close( _cs  );
	if( _cs ) return;
  }
  QAbstractSocket::close(  );
}
bool DaoCxx_QAbstractSocket::isSequential(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "isSequential" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _isSequential = DaoCxxVirt_QIODevice::isSequential( _cs  );
	if( _cs ) return _isSequential;
  }
  return QAbstractSocket::isSequential(  );
}
qint64 DaoCxx_QAbstractSocket::readData( char* data, qint64 maxlen )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _readData = DaoCxxVirt_QIODevice::readData( _cs, data, maxlen );
	if( _cs ) return _readData;
  }
  return QAbstractSocket::readData( data, maxlen );
}
qint64 DaoCxx_QAbstractSocket::readLineData( char* data, qint64 maxlen )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readLineData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _readLineData = DaoCxxVirt_QIODevice::readLineData( _cs, data, maxlen );
	if( _cs ) return _readLineData;
  }
  return QAbstractSocket::readLineData( data, maxlen );
}
bool DaoCxx_QAbstractSocket::waitForBytesWritten( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForBytesWritten" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForBytesWritten = DaoCxxVirt_QIODevice::waitForBytesWritten( _cs, msecs );
	if( _cs ) return _waitForBytesWritten;
  }
  return QAbstractSocket::waitForBytesWritten( msecs );
}
bool DaoCxx_QAbstractSocket::waitForReadyRead( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForReadyRead" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForReadyRead = DaoCxxVirt_QIODevice::waitForReadyRead( _cs, msecs );
	if( _cs ) return _waitForReadyRead;
  }
  return QAbstractSocket::waitForReadyRead( msecs );
}
qint64 DaoCxx_QAbstractSocket::writeData( const char* data, qint64 len )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "writeData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _writeData = DaoCxxVirt_QIODevice::writeData( _cs, data, len );
	if( _cs ) return _writeData;
  }
  return QAbstractSocket::writeData( data, len );
}



QAuthenticator* DAO_DLL_QTNETWORK Dao_QAuthenticator_New(  )
{
	QAuthenticator *object = new QAuthenticator(  );
	return object;
}
QAuthenticator* DAO_DLL_QTNETWORK Dao_QAuthenticator_New( const QAuthenticator &other )
{
	QAuthenticator *object = new QAuthenticator( other );
	return object;
}

void DAO_DLL_QTNETWORK Dao_QFtp_InitSS( QFtp *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QFtp *linker = new DaoSS_QFtp();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QFtp* DAO_DLL_QTNETWORK DaoCxx_QFtp_New( QObject* parent )
{
	DaoCxx_QFtp *self = new DaoCxx_QFtp( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QFtp::slot_abort121( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_abort121(  );
}
void DaoSS_QFtp::slot_stateChanged776( int _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_stateChanged776( this, "stateChanged(int)", _message );
}
void DaoSS_QFtp::slot_listInfo695( const QUrlInfo &_cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_WrapCData( dao_QUrlInfo_Typer, (void*) & _cp0 );
  emit signal_listInfo695( this, "listInfo(const QUrlInfo&)", _message );
}
void DaoSS_QFtp::slot_readyRead67(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_readyRead67( this, "readyRead()", _message );
}
void DaoSS_QFtp::slot_dataTransferProgress758( qint64 _cp0, qint64 _cp1 )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewDouble( (double) _cp0 );
  _dp[1] = DValue_NewDouble( (double) _cp1 );
  emit signal_dataTransferProgress758( this, "dataTransferProgress(qint64,qint64)", _message );
}
void DaoSS_QFtp::slot_rawCommandReply437( int _cp0, const QString &_cp1 )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  _dp[1] = DValue_NewMBString( (char*) _cp1.toLocal8Bit().data(), 0 );
  emit signal_rawCommandReply437( this, "rawCommandReply(int,const QString&)", _message );
}
void DaoSS_QFtp::slot_commandStarted774( int _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_commandStarted774( this, "commandStarted(int)", _message );
}
void DaoSS_QFtp::slot_commandFinished467( int _cp0, bool _cp1 )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  _dp[1] = DValue_NewInteger( (int) _cp1 );
  emit signal_commandFinished467( this, "commandFinished(int,bool)", _message );
}
void DaoSS_QFtp::slot_done575( bool _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_done575( this, "done(bool)", _message );
}
void DaoCxxVirt_QFtp::DaoInitWrapper( QFtp *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QFtp::~DaoCxx_QFtp()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QFtp::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QFtp_Typer, this );
	DaoCxxVirt_QFtp::DaoInitWrapper( this, cdata );
   DaoSS_QFtp *linker = new DaoSS_QFtp();
   setUserData( 0, linker );
   linker->Init( cdata );
}
void DaoCxxVirt_QFtp::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QFtp::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QFtp::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QFtp::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QFtp::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QFtp::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QFtp::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
void DaoCxx_QFtp::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QFtp::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QFtp::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QFtp::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
void DaoCxx_QFtp::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QFtp::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
void DaoCxx_QFtp::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QFtp::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QFtp::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QFtp::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QFtp::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QFtp::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
void DaoCxx_QFtp::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QFtp::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}


QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New(  )
{
	QHostAddress *object = new QHostAddress(  );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( QHostAddress::SpecialAddress address )
{
	QHostAddress *object = new QHostAddress( address );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( const QHostAddress &copy )
{
	QHostAddress *object = new QHostAddress( copy );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( const QString &address )
{
	QHostAddress *object = new QHostAddress( address );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( const Q_IPV6ADDR &ip6Addr )
{
	QHostAddress *object = new QHostAddress( ip6Addr );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( const sockaddr* sa )
{
	QHostAddress *object = new QHostAddress( sa );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( quint32 ip4Addr )
{
	QHostAddress *object = new QHostAddress( ip4Addr );
	return object;
}
QHostAddress* DAO_DLL_QTNETWORK Dao_QHostAddress_New( quint8* ip6Addr )
{
	QHostAddress *object = new QHostAddress( ip6Addr );
	return object;
}


QHostInfo* DAO_DLL_QTNETWORK Dao_QHostInfo_New( const QHostInfo &d )
{
	QHostInfo *object = new QHostInfo( d );
	return object;
}
QHostInfo* DAO_DLL_QTNETWORK Dao_QHostInfo_New( int lookupId )
{
	QHostInfo *object = new QHostInfo( lookupId );
	return object;
}

void DAO_DLL_QTNETWORK Dao_QHttp_InitSS( QHttp *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QHttp *linker = new DaoSS_QHttp();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QHttp* DAO_DLL_QTNETWORK DaoCxx_QHttp_New( QObject* parent )
{
	DaoCxx_QHttp *self = new DaoCxx_QHttp( parent );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttp* DAO_DLL_QTNETWORK DaoCxx_QHttp_New( const QString &hostname, QHttp::ConnectionMode mode, quint16 port, QObject* parent )
{
	DaoCxx_QHttp *self = new DaoCxx_QHttp( hostname, mode, port, parent );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttp* DAO_DLL_QTNETWORK DaoCxx_QHttp_New( const QString &hostname, quint16 port, QObject* parent )
{
	DaoCxx_QHttp *self = new DaoCxx_QHttp( hostname, port, parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QHttp::slot_abort121( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_abort121(  );
}
void DaoSS_QHttp::slot_ignoreSslErrors485( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_ignoreSslErrors485(  );
}
void DaoSS_QHttp::slot_stateChanged776( int _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_stateChanged776( this, "stateChanged(int)", _message );
}
void DaoSS_QHttp::slot_responseHeaderReceived850( const QHttpResponseHeader &resp )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_WrapCData( dao_QHttpResponseHeader_Typer, (void*) & resp );
  emit signal_responseHeaderReceived850( this, "responseHeaderReceived(const QHttpResponseHeader&)", _message );
}
void DaoSS_QHttp::slot_readyRead75( const QHttpResponseHeader &resp )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_WrapCData( dao_QHttpResponseHeader_Typer, (void*) & resp );
  emit signal_readyRead75( this, "readyRead(const QHttpResponseHeader&)", _message );
}
void DaoSS_QHttp::slot_dataSendProgress70( int _cp0, int _cp1 )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  _dp[1] = DValue_NewInteger( (int) _cp1 );
  emit signal_dataSendProgress70( this, "dataSendProgress(int,int)", _message );
}
void DaoSS_QHttp::slot_dataReadProgress80( int _cp0, int _cp1 )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  _dp[1] = DValue_NewInteger( (int) _cp1 );
  emit signal_dataReadProgress80( this, "dataReadProgress(int,int)", _message );
}
void DaoSS_QHttp::slot_requestStarted130( int _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_requestStarted130( this, "requestStarted(int)", _message );
}
void DaoSS_QHttp::slot_requestFinished872( int _cp0, bool _cp1 )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  _dp[1] = DValue_NewInteger( (int) _cp1 );
  emit signal_requestFinished872( this, "requestFinished(int,bool)", _message );
}
void DaoSS_QHttp::slot_done575( bool _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_done575( this, "done(bool)", _message );
}
void DaoSS_QHttp::slot_authenticationRequired54( const QString &hostname, quint16 port, QAuthenticator* _cp2 )
{
  DaoQtMessage _message( 3 );
  assert( 3 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewMBString( (char*) hostname.toLocal8Bit().data(), 0 );
  _dp[1] = DValue_NewInteger( (int) port );
  _dp[2] = DValue_WrapCData( dao_QAuthenticator_Typer, (void*) _cp2 );
  emit signal_authenticationRequired54( this, "authenticationRequired(const QString&,quint16,QAuthenticator*)", _message );
}
void DaoCxxVirt_QHttp::DaoInitWrapper( QHttp *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QHttp::~DaoCxx_QHttp()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QHttp::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QHttp_Typer, this );
	DaoCxxVirt_QHttp::DaoInitWrapper( this, cdata );
   DaoSS_QHttp *linker = new DaoSS_QHttp();
   setUserData( 0, linker );
   linker->Init( cdata );
}
void DaoCxxVirt_QHttp::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QHttp::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QHttp::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QHttp::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QHttp::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QHttp::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QHttp::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
void DaoCxx_QHttp::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QHttp::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QHttp::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QHttp::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
void DaoCxx_QHttp::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QHttp::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
void DaoCxx_QHttp::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QHttp::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QHttp::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QHttp::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QHttp::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QHttp::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
void DaoCxx_QHttp::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QHttp::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}


DaoCxx_QHttpHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpHeader_New(  )
{
	DaoCxx_QHttpHeader *self = new DaoCxx_QHttpHeader(  );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpHeader_New( QHttpHeaderPrivate &dd, const QHttpHeader &header )
{
	DaoCxx_QHttpHeader *self = new DaoCxx_QHttpHeader( dd, header );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpHeader_New( QHttpHeaderPrivate &dd, const QString &str )
{
	DaoCxx_QHttpHeader *self = new DaoCxx_QHttpHeader( dd, str );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpHeader_New( const QHttpHeader &header )
{
	DaoCxx_QHttpHeader *self = new DaoCxx_QHttpHeader( header );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpHeader_New( const QString &str )
{
	DaoCxx_QHttpHeader *self = new DaoCxx_QHttpHeader( str );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QHttpHeader::DaoInitWrapper( QHttpHeader *s, DaoCData *d )
{
	self = s;
	cdata = d;

}
DaoCxx_QHttpHeader::~DaoCxx_QHttpHeader()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QHttpHeader::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QHttpHeader_Typer, this );
	DaoCxxVirt_QHttpHeader::DaoInitWrapper( this, cdata );
}
int DaoCxxVirt_QHttpHeader::majorVersion( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "majorVersion" );
  int _majorVersion= (int)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _majorVersion;
  return (int)Function_1002d( & _cs, _ro, & _obj );
}
int DaoCxxVirt_QHttpHeader::minorVersion( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "minorVersion" );
  int _minorVersion= (int)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _minorVersion;
  return (int)Function_1002d( & _cs, _ro, & _obj );
}
bool DaoCxxVirt_QHttpHeader::parseLine( int &_cs, const QString &line, int number )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "parseLine" );
  bool _parseLine= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _parseLine;
  return (bool)Function_10236( & _cs, _ro, & _obj, line, number );
}
QString DaoCxxVirt_QHttpHeader::toString( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "toString" );
  QString _toString;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _toString;
  return (QString)Function_10016( & _cs, _ro, & _obj );
}
int DaoCxx_QHttpHeader::majorVersion(  )const
{
  int _cs = 0;
  return DaoCxxVirt_QHttpHeader::majorVersion( _cs  );
}
int DaoCxx_QHttpHeader::minorVersion(  )const
{
  int _cs = 0;
  return DaoCxxVirt_QHttpHeader::minorVersion( _cs  );
}
bool DaoCxx_QHttpHeader::parseLine( const QString &line, int number )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "parseLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _parseLine = DaoCxxVirt_QHttpHeader::parseLine( _cs, line, number );
	if( _cs ) return _parseLine;
  }
  return QHttpHeader::parseLine( line, number );
}
QString DaoCxx_QHttpHeader::toString(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "toString" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QString _toString = DaoCxxVirt_QHttpHeader::toString( _cs  );
	if( _cs ) return _toString;
  }
  return QHttpHeader::toString(  );
}



DaoCxx_QHttpRequestHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpRequestHeader_New(  )
{
	DaoCxx_QHttpRequestHeader *self = new DaoCxx_QHttpRequestHeader(  );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpRequestHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpRequestHeader_New( const QHttpRequestHeader &header )
{
	DaoCxx_QHttpRequestHeader *self = new DaoCxx_QHttpRequestHeader( header );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpRequestHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpRequestHeader_New( const QString &str )
{
	DaoCxx_QHttpRequestHeader *self = new DaoCxx_QHttpRequestHeader( str );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpRequestHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpRequestHeader_New( const QString &method, const QString &path, int majorVer, int minorVer )
{
	DaoCxx_QHttpRequestHeader *self = new DaoCxx_QHttpRequestHeader( method, path, majorVer, minorVer );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QHttpRequestHeader::DaoInitWrapper( QHttpRequestHeader *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QHttpHeader::DaoInitWrapper( s, d );
}
DaoCxx_QHttpRequestHeader::~DaoCxx_QHttpRequestHeader()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QHttpRequestHeader::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QHttpRequestHeader_Typer, this );
	DaoCxxVirt_QHttpRequestHeader::DaoInitWrapper( this, cdata );
}
QHttpRequestHeader* DAO_DLL_QTNETWORK Dao_QHttpRequestHeader_Copy( const QHttpRequestHeader &p )
{
	QHttpRequestHeader *object = new QHttpRequestHeader( p );
	return object;
}
int DaoCxx_QHttpRequestHeader::majorVersion(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "majorVersion" );
  if( _ro && _obj.t == DAO_OBJECT ){
    int _majorVersion = DaoCxxVirt_QHttpHeader::majorVersion( _cs  );
	if( _cs ) return _majorVersion;
  }
  return QHttpRequestHeader::majorVersion(  );
}
int DaoCxx_QHttpRequestHeader::minorVersion(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "minorVersion" );
  if( _ro && _obj.t == DAO_OBJECT ){
    int _minorVersion = DaoCxxVirt_QHttpHeader::minorVersion( _cs  );
	if( _cs ) return _minorVersion;
  }
  return QHttpRequestHeader::minorVersion(  );
}
bool DaoCxx_QHttpRequestHeader::parseLine( const QString &line, int number )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "parseLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _parseLine = DaoCxxVirt_QHttpHeader::parseLine( _cs, line, number );
	if( _cs ) return _parseLine;
  }
  return QHttpRequestHeader::parseLine( line, number );
}
QString DaoCxx_QHttpRequestHeader::toString(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "toString" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QString _toString = DaoCxxVirt_QHttpHeader::toString( _cs  );
	if( _cs ) return _toString;
  }
  return QHttpRequestHeader::toString(  );
}


DaoCxx_QHttpResponseHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpResponseHeader_New(  )
{
	DaoCxx_QHttpResponseHeader *self = new DaoCxx_QHttpResponseHeader(  );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpResponseHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpResponseHeader_New( const QHttpResponseHeader &header )
{
	DaoCxx_QHttpResponseHeader *self = new DaoCxx_QHttpResponseHeader( header );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpResponseHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpResponseHeader_New( const QString &str )
{
	DaoCxx_QHttpResponseHeader *self = new DaoCxx_QHttpResponseHeader( str );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QHttpResponseHeader* DAO_DLL_QTNETWORK DaoCxx_QHttpResponseHeader_New( int code, const QString &text, int majorVer, int minorVer )
{
	DaoCxx_QHttpResponseHeader *self = new DaoCxx_QHttpResponseHeader( code, text, majorVer, minorVer );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QHttpResponseHeader::DaoInitWrapper( QHttpResponseHeader *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QHttpHeader::DaoInitWrapper( s, d );
}
DaoCxx_QHttpResponseHeader::~DaoCxx_QHttpResponseHeader()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QHttpResponseHeader::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QHttpResponseHeader_Typer, this );
	DaoCxxVirt_QHttpResponseHeader::DaoInitWrapper( this, cdata );
}
QHttpResponseHeader* DAO_DLL_QTNETWORK Dao_QHttpResponseHeader_Copy( const QHttpResponseHeader &p )
{
	QHttpResponseHeader *object = new QHttpResponseHeader( p );
	return object;
}
int DaoCxx_QHttpResponseHeader::majorVersion(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "majorVersion" );
  if( _ro && _obj.t == DAO_OBJECT ){
    int _majorVersion = DaoCxxVirt_QHttpHeader::majorVersion( _cs  );
	if( _cs ) return _majorVersion;
  }
  return QHttpResponseHeader::majorVersion(  );
}
int DaoCxx_QHttpResponseHeader::minorVersion(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "minorVersion" );
  if( _ro && _obj.t == DAO_OBJECT ){
    int _minorVersion = DaoCxxVirt_QHttpHeader::minorVersion( _cs  );
	if( _cs ) return _minorVersion;
  }
  return QHttpResponseHeader::minorVersion(  );
}
bool DaoCxx_QHttpResponseHeader::parseLine( const QString &line, int number )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "parseLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _parseLine = DaoCxxVirt_QHttpHeader::parseLine( _cs, line, number );
	if( _cs ) return _parseLine;
  }
  return QHttpResponseHeader::parseLine( line, number );
}
QString DaoCxx_QHttpResponseHeader::toString(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "toString" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QString _toString = DaoCxxVirt_QHttpHeader::toString( _cs  );
	if( _cs ) return _toString;
  }
  return QHttpResponseHeader::toString(  );
}

QIPv6Address* Dao_QIPv6Address_New()
{
	QIPv6Address *self = new QIPv6Address();
	return self;
}

void DAO_DLL_QTNETWORK Dao_QLocalServer_InitSS( QLocalServer *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QLocalServer *linker = new DaoSS_QLocalServer();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QLocalServer* DAO_DLL_QTNETWORK DaoCxx_QLocalServer_New( QObject* parent )
{
	DaoCxx_QLocalServer *self = new DaoCxx_QLocalServer( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QLocalServer::slot_newConnection771(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_newConnection771( this, "newConnection()", _message );
}
void DaoCxxVirt_QLocalServer::DaoInitWrapper( QLocalServer *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QLocalServer::~DaoCxx_QLocalServer()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QLocalServer::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QLocalServer_Typer, this );
	DaoCxxVirt_QLocalServer::DaoInitWrapper( this, cdata );
   DaoSS_QLocalServer *linker = new DaoSS_QLocalServer();
   setUserData( 0, linker );
   linker->Init( cdata );
}
bool DaoCxxVirt_QLocalServer::hasPendingConnections( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "hasPendingConnections" );
  bool _hasPendingConnections= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _hasPendingConnections;
  return (bool)Function_10018( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QLocalServer::incomingConnection( int &_cs, quintptr socketDescriptor )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "incomingConnection" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_1027b( & _cs, _ro, & _obj, socketDescriptor );
}
QLocalSocket* DaoCxxVirt_QLocalServer::nextPendingConnection( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "nextPendingConnection" );
  QLocalSocket* _nextPendingConnection = NULL;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _nextPendingConnection;
  return (QLocalSocket*)Function_1027d( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QLocalServer::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QLocalServer::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QLocalServer::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QLocalServer::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QLocalServer::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QLocalServer::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QLocalServer::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
void DaoCxx_QLocalServer::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalServer::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QLocalServer::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalServer::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
void DaoCxx_QLocalServer::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalServer::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
void DaoCxx_QLocalServer::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalServer::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QLocalServer::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QLocalServer::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QLocalServer::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QLocalServer::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
bool DaoCxx_QLocalServer::hasPendingConnections(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "hasPendingConnections" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _hasPendingConnections = DaoCxxVirt_QLocalServer::hasPendingConnections( _cs  );
	if( _cs ) return _hasPendingConnections;
  }
  return QLocalServer::hasPendingConnections(  );
}
void DaoCxx_QLocalServer::incomingConnection( quintptr socketDescriptor )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "incomingConnection" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalServer::incomingConnection( _cs, socketDescriptor );
	if( _cs ) return;
  }
  QLocalServer::incomingConnection( socketDescriptor );
}
QLocalSocket* DaoCxx_QLocalServer::nextPendingConnection(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "nextPendingConnection" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QLocalSocket* _nextPendingConnection = DaoCxxVirt_QLocalServer::nextPendingConnection( _cs  );
	if( _cs ) return _nextPendingConnection;
  }
  return QLocalServer::nextPendingConnection(  );
}
void DaoCxx_QLocalServer::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalServer::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}

void DAO_DLL_QTNETWORK Dao_QLocalSocket_InitSS( QLocalSocket *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QLocalSocket *linker = new DaoSS_QLocalSocket();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QLocalSocket* DAO_DLL_QTNETWORK DaoCxx_QLocalSocket_New( QObject* parent )
{
	DaoCxx_QLocalSocket *self = new DaoCxx_QLocalSocket( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QLocalSocket::slot_connected94(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_connected94( this, "connected()", _message );
}
void DaoSS_QLocalSocket::slot_disconnected23(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_disconnected23( this, "disconnected()", _message );
}
void DaoSS_QLocalSocket::slot_error107( QLocalSocket::LocalSocketError socketError )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) socketError );
  emit signal_error107( this, "error(QLocalSocket::LocalSocketError)", _message );
}
void DaoSS_QLocalSocket::slot_stateChanged840( QLocalSocket::LocalSocketState socketState )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) socketState );
  emit signal_stateChanged840( this, "stateChanged(QLocalSocket::LocalSocketState)", _message );
}
void DaoCxxVirt_QLocalSocket::DaoInitWrapper( QLocalSocket *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QIODevice::DaoInitWrapper( s, d );
}
DaoCxx_QLocalSocket::~DaoCxx_QLocalSocket()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QLocalSocket::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QLocalSocket_Typer, this );
	DaoCxxVirt_QLocalSocket::DaoInitWrapper( this, cdata );
   DaoSS_QLocalSocket *linker = new DaoSS_QLocalSocket();
   setUserData( 0, linker );
   linker->Init( cdata );
}
qint64 DaoCxxVirt_QLocalSocket::bytesAvailable( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesAvailable" );
  qint64 _bytesAvailable= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _bytesAvailable;
  return (qint64)Function_10042( & _cs, _ro, & _obj );
}
qint64 DaoCxxVirt_QLocalSocket::bytesToWrite( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesToWrite" );
  qint64 _bytesToWrite= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _bytesToWrite;
  return (qint64)Function_10042( & _cs, _ro, & _obj );
}
bool DaoCxxVirt_QLocalSocket::canReadLine( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "canReadLine" );
  bool _canReadLine= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _canReadLine;
  return (bool)Function_10018( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QLocalSocket::close( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "close" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  _ro = DaoMethod_Resolve( _ro, & _obj, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  DaoVmProcess_Call( _vmp, _ro, & _obj, NULL, 0 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
}
bool DaoCxxVirt_QLocalSocket::isSequential( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "isSequential" );
  bool _isSequential= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _isSequential;
  return (bool)Function_10018( & _cs, _ro, & _obj );
}
qint64 DaoCxxVirt_QLocalSocket::readData( int &_cs, char* _cp0, qint64 _cp1 )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readData" );
  qint64 _readData= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _readData;
  return (qint64)Function_10050( & _cs, _ro, & _obj, _cp0, _cp1 );
}
qint64 DaoCxxVirt_QLocalSocket::writeData( int &_cs, const char* _cp0, qint64 _cp1 )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "writeData" );
  qint64 _writeData= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _writeData;
  return (qint64)Function_10051( & _cs, _ro, & _obj, _cp0, _cp1 );
}
bool DaoCxxVirt_QLocalSocket::atEnd( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::atEnd( _cs  );
}
bool DaoCxxVirt_QLocalSocket::open( int &_cs, QIODevice::OpenMode mode )
{
  return DaoCxxVirt_QIODevice::open( _cs, mode );
}
qint64 DaoCxxVirt_QLocalSocket::pos( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::pos( _cs  );
}
qint64 DaoCxxVirt_QLocalSocket::readLineData( int &_cs, char* data, qint64 maxlen )
{
  return DaoCxxVirt_QIODevice::readLineData( _cs, data, maxlen );
}
bool DaoCxxVirt_QLocalSocket::reset( int &_cs  )
{
  return DaoCxxVirt_QIODevice::reset( _cs  );
}
bool DaoCxxVirt_QLocalSocket::seek( int &_cs, qint64 pos )
{
  return DaoCxxVirt_QIODevice::seek( _cs, pos );
}
qint64 DaoCxxVirt_QLocalSocket::size( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::size( _cs  );
}
bool DaoCxx_QLocalSocket::atEnd(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "atEnd" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _atEnd = DaoCxxVirt_QLocalSocket::atEnd( _cs  );
	if( _cs ) return _atEnd;
  }
  return QIODevice::atEnd(  );
}
qint64 DaoCxx_QLocalSocket::bytesAvailable(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesAvailable" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesAvailable = DaoCxxVirt_QLocalSocket::bytesAvailable( _cs  );
	if( _cs ) return _bytesAvailable;
  }
  return QLocalSocket::bytesAvailable(  );
}
qint64 DaoCxx_QLocalSocket::bytesToWrite(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesToWrite" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesToWrite = DaoCxxVirt_QLocalSocket::bytesToWrite( _cs  );
	if( _cs ) return _bytesToWrite;
  }
  return QLocalSocket::bytesToWrite(  );
}
bool DaoCxx_QLocalSocket::canReadLine(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "canReadLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _canReadLine = DaoCxxVirt_QLocalSocket::canReadLine( _cs  );
	if( _cs ) return _canReadLine;
  }
  return QLocalSocket::canReadLine(  );
}
void DaoCxx_QLocalSocket::close(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "close" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QLocalSocket::close( _cs  );
	if( _cs ) return;
  }
  QLocalSocket::close(  );
}
bool DaoCxx_QLocalSocket::isSequential(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "isSequential" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _isSequential = DaoCxxVirt_QLocalSocket::isSequential( _cs  );
	if( _cs ) return _isSequential;
  }
  return QLocalSocket::isSequential(  );
}
bool DaoCxx_QLocalSocket::open( QIODevice::OpenMode mode )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "open" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _open = DaoCxxVirt_QLocalSocket::open( _cs, mode );
	if( _cs ) return _open;
  }
  return QIODevice::open( mode );
}
qint64 DaoCxx_QLocalSocket::pos(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "pos" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _pos = DaoCxxVirt_QLocalSocket::pos( _cs  );
	if( _cs ) return _pos;
  }
  return QIODevice::pos(  );
}
qint64 DaoCxx_QLocalSocket::readData( char* _cp0, qint64 _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _readData = DaoCxxVirt_QLocalSocket::readData( _cs, _cp0, _cp1 );
	if( _cs ) return _readData;
  }
  return QLocalSocket::readData( _cp0, _cp1 );
}
qint64 DaoCxx_QLocalSocket::readLineData( char* data, qint64 maxlen )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readLineData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _readLineData = DaoCxxVirt_QLocalSocket::readLineData( _cs, data, maxlen );
	if( _cs ) return _readLineData;
  }
  return QIODevice::readLineData( data, maxlen );
}
bool DaoCxx_QLocalSocket::reset(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "reset" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _reset = DaoCxxVirt_QLocalSocket::reset( _cs  );
	if( _cs ) return _reset;
  }
  return QIODevice::reset(  );
}
bool DaoCxx_QLocalSocket::seek( qint64 pos )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "seek" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _seek = DaoCxxVirt_QLocalSocket::seek( _cs, pos );
	if( _cs ) return _seek;
  }
  return QIODevice::seek( pos );
}
qint64 DaoCxx_QLocalSocket::size(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "size" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _size = DaoCxxVirt_QLocalSocket::size( _cs  );
	if( _cs ) return _size;
  }
  return QIODevice::size(  );
}
qint64 DaoCxx_QLocalSocket::writeData( const char* _cp0, qint64 _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "writeData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _writeData = DaoCxxVirt_QLocalSocket::writeData( _cs, _cp0, _cp1 );
	if( _cs ) return _writeData;
  }
  return QLocalSocket::writeData( _cp0, _cp1 );
}
bool DaoCxx_QLocalSocket::waitForBytesWritten( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForBytesWritten" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForBytesWritten = DaoCxxVirt_QIODevice::waitForBytesWritten( _cs, msecs );
	if( _cs ) return _waitForBytesWritten;
  }
  return QLocalSocket::waitForBytesWritten( msecs );
}
bool DaoCxx_QLocalSocket::waitForReadyRead( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForReadyRead" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForReadyRead = DaoCxxVirt_QIODevice::waitForReadyRead( _cs, msecs );
	if( _cs ) return _waitForReadyRead;
  }
  return QLocalSocket::waitForReadyRead( msecs );
}

void DAO_DLL_QTNETWORK Dao_QNetworkAccessManager_InitSS( QNetworkAccessManager *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QNetworkAccessManager *linker = new DaoSS_QNetworkAccessManager();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QNetworkAccessManager* DAO_DLL_QTNETWORK DaoCxx_QNetworkAccessManager_New( QObject* parent )
{
	DaoCxx_QNetworkAccessManager *self = new DaoCxx_QNetworkAccessManager( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QNetworkAccessManager::slot_authenticationRequired61( QNetworkReply* reply, QAuthenticator* authenticator )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_WrapCData( dao_QNetworkReply_Typer, (void*) reply );
  _dp[1] = DValue_WrapCData( dao_QAuthenticator_Typer, (void*) authenticator );
  emit signal_authenticationRequired61( this, "authenticationRequired(QNetworkReply*,QAuthenticator*)", _message );
}
void DaoSS_QNetworkAccessManager::slot_finished342( QNetworkReply* reply )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_WrapCData( dao_QNetworkReply_Typer, (void*) reply );
  emit signal_finished342( this, "finished(QNetworkReply*)", _message );
}
void DaoSS_QNetworkAccessManager::slot_networkAccessibleChanged414( QNetworkAccessManager::NetworkAccessibility accessible )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) accessible );
  emit signal_networkAccessibleChanged414( this, "networkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility)", _message );
}
void DaoCxxVirt_QNetworkAccessManager::DaoInitWrapper( QNetworkAccessManager *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QNetworkAccessManager::~DaoCxx_QNetworkAccessManager()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QNetworkAccessManager::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QNetworkAccessManager_Typer, this );
	DaoCxxVirt_QNetworkAccessManager::DaoInitWrapper( this, cdata );
   DaoSS_QNetworkAccessManager *linker = new DaoSS_QNetworkAccessManager();
   setUserData( 0, linker );
   linker->Init( cdata );
}
QNetworkReply* DaoCxxVirt_QNetworkAccessManager::createRequest( int &_cs, int op, const QNetworkRequest &request, QIODevice* outgoingData )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "createRequest" );
  QNetworkReply* _createRequest = NULL;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _createRequest;
  return (QNetworkReply*)Function_102fb( & _cs, _ro, & _obj, op, request, outgoingData );
}
void DaoCxxVirt_QNetworkAccessManager::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QNetworkAccessManager::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QNetworkAccessManager::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QNetworkAccessManager::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QNetworkAccessManager::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QNetworkAccessManager::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QNetworkAccessManager::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
void DaoCxx_QNetworkAccessManager::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkAccessManager::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QNetworkAccessManager::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkAccessManager::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
QNetworkReply* DaoCxx_QNetworkAccessManager::createRequest( QNetworkAccessManager::Operation op, const QNetworkRequest &request, QIODevice* outgoingData )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "createRequest" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QNetworkReply* _createRequest = DaoCxxVirt_QNetworkAccessManager::createRequest( _cs, op, request, outgoingData );
	if( _cs ) return _createRequest;
  }
  return QNetworkAccessManager::createRequest( op, request, outgoingData );
}
void DaoCxx_QNetworkAccessManager::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkAccessManager::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
void DaoCxx_QNetworkAccessManager::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkAccessManager::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QNetworkAccessManager::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QNetworkAccessManager::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QNetworkAccessManager::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QNetworkAccessManager::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
void DaoCxx_QNetworkAccessManager::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkAccessManager::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}


QNetworkAddressEntry* DAO_DLL_QTNETWORK Dao_QNetworkAddressEntry_New(  )
{
	QNetworkAddressEntry *object = new QNetworkAddressEntry(  );
	return object;
}
QNetworkAddressEntry* DAO_DLL_QTNETWORK Dao_QNetworkAddressEntry_New( const QNetworkAddressEntry &other )
{
	QNetworkAddressEntry *object = new QNetworkAddressEntry( other );
	return object;
}


QNetworkCacheMetaData* DAO_DLL_QTNETWORK Dao_QNetworkCacheMetaData_New(  )
{
	QNetworkCacheMetaData *object = new QNetworkCacheMetaData(  );
	return object;
}
QNetworkCacheMetaData* DAO_DLL_QTNETWORK Dao_QNetworkCacheMetaData_New( const QNetworkCacheMetaData &other )
{
	QNetworkCacheMetaData *object = new QNetworkCacheMetaData( other );
	return object;
}





QNetworkCookie* DAO_DLL_QTNETWORK Dao_QNetworkCookie_New( const QByteArray &name, const QByteArray &value )
{
	QNetworkCookie *object = new QNetworkCookie( name, value );
	return object;
}
QNetworkCookie* DAO_DLL_QTNETWORK Dao_QNetworkCookie_New( const QNetworkCookie &other )
{
	QNetworkCookie *object = new QNetworkCookie( other );
	return object;
}

void DAO_DLL_QTNETWORK Dao_QNetworkCookieJar_InitSS( QNetworkCookieJar *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QNetworkCookieJar *linker = new DaoSS_QNetworkCookieJar();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QNetworkCookieJar* DAO_DLL_QTNETWORK DaoCxx_QNetworkCookieJar_New( QObject* parent )
{
	DaoCxx_QNetworkCookieJar *self = new DaoCxx_QNetworkCookieJar( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QNetworkCookieJar::DaoInitWrapper( QNetworkCookieJar *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QNetworkCookieJar::~DaoCxx_QNetworkCookieJar()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QNetworkCookieJar::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QNetworkCookieJar_Typer, this );
	DaoCxxVirt_QNetworkCookieJar::DaoInitWrapper( this, cdata );
   DaoSS_QNetworkCookieJar *linker = new DaoSS_QNetworkCookieJar();
   setUserData( 0, linker );
   linker->Init( cdata );
}
void DaoCxxVirt_QNetworkCookieJar::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QNetworkCookieJar::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QNetworkCookieJar::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QNetworkCookieJar::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QNetworkCookieJar::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QNetworkCookieJar::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QNetworkCookieJar::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
void DaoCxx_QNetworkCookieJar::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkCookieJar::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QNetworkCookieJar::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkCookieJar::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
void DaoCxx_QNetworkCookieJar::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkCookieJar::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
void DaoCxx_QNetworkCookieJar::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkCookieJar::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QNetworkCookieJar::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QNetworkCookieJar::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QNetworkCookieJar::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QNetworkCookieJar::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
void DaoCxx_QNetworkCookieJar::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkCookieJar::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}

void DAO_DLL_QTNETWORK Dao_QNetworkDiskCache_InitSS( QNetworkDiskCache *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QNetworkDiskCache *linker = new DaoSS_QNetworkDiskCache();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QNetworkDiskCache* DAO_DLL_QTNETWORK DaoCxx_QNetworkDiskCache_New( QObject* parent )
{
	DaoCxx_QNetworkDiskCache *self = new DaoCxx_QNetworkDiskCache( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QNetworkDiskCache::slot_clear12( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_clear12(  );
}
void DaoCxxVirt_QNetworkDiskCache::DaoInitWrapper( QNetworkDiskCache *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QAbstractNetworkCache::DaoInitWrapper( s, d );
}
DaoCxx_QNetworkDiskCache::~DaoCxx_QNetworkDiskCache()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QNetworkDiskCache::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QNetworkDiskCache_Typer, this );
	DaoCxxVirt_QNetworkDiskCache::DaoInitWrapper( this, cdata );
   DaoSS_QNetworkDiskCache *linker = new DaoSS_QNetworkDiskCache();
   setUserData( 0, linker );
   linker->Init( cdata );
}
qint64 DaoCxxVirt_QNetworkDiskCache::expire( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "expire" );
  qint64 _expire= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _expire;
  return (qint64)Function_10160( & _cs, _ro, & _obj );
}
qint64 DaoCxx_QNetworkDiskCache::expire(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "expire" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _expire = DaoCxxVirt_QNetworkDiskCache::expire( _cs  );
	if( _cs ) return _expire;
  }
  return QNetworkDiskCache::expire(  );
}
qint64 DaoCxx_QNetworkDiskCache::cacheSize(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "cacheSize" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _cacheSize = DaoCxxVirt_QAbstractNetworkCache::cacheSize( _cs  );
	if( _cs ) return _cacheSize;
  }
  return QNetworkDiskCache::cacheSize(  );
}
void DaoCxx_QNetworkDiskCache::clear(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "clear" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::clear( _cs  );
	if( _cs ) return;
  }
  QNetworkDiskCache::clear(  );
}
QIODevice* DaoCxx_QNetworkDiskCache::data( const QUrl &url )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "data" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QIODevice* _data = DaoCxxVirt_QAbstractNetworkCache::data( _cs, url );
	if( _cs ) return _data;
  }
  return QNetworkDiskCache::data( url );
}
void DaoCxx_QNetworkDiskCache::insert( QIODevice* device )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "insert" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::insert( _cs, device );
	if( _cs ) return;
  }
  QNetworkDiskCache::insert( device );
}
QNetworkCacheMetaData DaoCxx_QNetworkDiskCache::metaData( const QUrl &url )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "metaData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QNetworkCacheMetaData _metaData = DaoCxxVirt_QAbstractNetworkCache::metaData( _cs, url );
	if( _cs ) return _metaData;
  }
  return QNetworkDiskCache::metaData( url );
}
QIODevice* DaoCxx_QNetworkDiskCache::prepare( const QNetworkCacheMetaData &metaData )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "prepare" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QIODevice* _prepare = DaoCxxVirt_QAbstractNetworkCache::prepare( _cs, metaData );
	if( _cs ) return _prepare;
  }
  return QNetworkDiskCache::prepare( metaData );
}
bool DaoCxx_QNetworkDiskCache::remove( const QUrl &url )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "remove" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _remove = DaoCxxVirt_QAbstractNetworkCache::remove( _cs, url );
	if( _cs ) return _remove;
  }
  return QNetworkDiskCache::remove( url );
}
void DaoCxx_QNetworkDiskCache::updateMetaData( const QNetworkCacheMetaData &metaData )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "updateMetaData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QAbstractNetworkCache::updateMetaData( _cs, metaData );
	if( _cs ) return;
  }
  QNetworkDiskCache::updateMetaData( metaData );
}


QNetworkInterface* DAO_DLL_QTNETWORK Dao_QNetworkInterface_New(  )
{
	QNetworkInterface *object = new QNetworkInterface(  );
	return object;
}
QNetworkInterface* DAO_DLL_QTNETWORK Dao_QNetworkInterface_New( const QNetworkInterface &other )
{
	QNetworkInterface *object = new QNetworkInterface( other );
	return object;
}

void DAO_DLL_QTNETWORK Dao_QNetworkReply_InitSS( QNetworkReply *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QNetworkReply *linker = new DaoSS_QNetworkReply();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QNetworkReply* DAO_DLL_QTNETWORK DaoCxx_QNetworkReply_New( QNetworkReplyPrivate &dd, QObject* parent )
{
	DaoCxx_QNetworkReply *self = new DaoCxx_QNetworkReply( dd, parent );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QNetworkReply* DAO_DLL_QTNETWORK DaoCxx_QNetworkReply_New( QObject* parent )
{
	DaoCxx_QNetworkReply *self = new DaoCxx_QNetworkReply( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QNetworkReply::slot_ignoreSslErrors485( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_ignoreSslErrors485(  );
}
void DaoSS_QNetworkReply::slot_metaDataChanged909(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_metaDataChanged909( this, "metaDataChanged()", _message );
}
void DaoSS_QNetworkReply::slot_finished719(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_finished719( this, "finished()", _message );
}
void DaoSS_QNetworkReply::slot_error745( QNetworkReply::NetworkError _cp0 )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) _cp0 );
  emit signal_error745( this, "error(QNetworkReply::NetworkError)", _message );
}
void DaoSS_QNetworkReply::slot_uploadProgress557( qint64 bytesSent, qint64 bytesTotal )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewDouble( (double) bytesSent );
  _dp[1] = DValue_NewDouble( (double) bytesTotal );
  emit signal_uploadProgress557( this, "uploadProgress(qint64,qint64)", _message );
}
void DaoSS_QNetworkReply::slot_downloadProgress594( qint64 bytesReceived, qint64 bytesTotal )
{
  DaoQtMessage _message( 2 );
  assert( 2 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewDouble( (double) bytesReceived );
  _dp[1] = DValue_NewDouble( (double) bytesTotal );
  emit signal_downloadProgress594( this, "downloadProgress(qint64,qint64)", _message );
}
void DaoCxxVirt_QNetworkReply::DaoInitWrapper( QNetworkReply *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QIODevice::DaoInitWrapper( s, d );
}
DaoCxx_QNetworkReply::~DaoCxx_QNetworkReply()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QNetworkReply::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QNetworkReply_Typer, this );
	DaoCxxVirt_QNetworkReply::DaoInitWrapper( this, cdata );
   DaoSS_QNetworkReply *linker = new DaoSS_QNetworkReply();
   setUserData( 0, linker );
   linker->Init( cdata );
}
void DaoCxxVirt_QNetworkReply::abort( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "abort" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  _ro = DaoMethod_Resolve( _ro, & _obj, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  DaoVmProcess_Call( _vmp, _ro, & _obj, NULL, 0 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
}
void DaoCxxVirt_QNetworkReply::close( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "close" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  _ro = DaoMethod_Resolve( _ro, & _obj, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  DaoVmProcess_Call( _vmp, _ro, & _obj, NULL, 0 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
}
void DaoCxxVirt_QNetworkReply::ignoreSslErrors( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "ignoreSslErrors" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  _ro = DaoMethod_Resolve( _ro, & _obj, NULL, 0 );
  if( _ro == NULL || _ro->type != DAO_ROUTINE ) return;
  DaoVmProcess *_vmp = DaoVmSpace_AcquireProcess( __daoVmSpace );
  DaoVmProcess_Call( _vmp, _ro, & _obj, NULL, 0 );
  DaoVmSpace_ReleaseProcess( __daoVmSpace, _vmp );
}
bool DaoCxxVirt_QNetworkReply::isSequential( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "isSequential" );
  bool _isSequential= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _isSequential;
  return (bool)Function_10018( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QNetworkReply::setReadBufferSize( int &_cs, qint64 size )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setReadBufferSize" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_1009f( & _cs, _ro, & _obj, size );
}
qint64 DaoCxxVirt_QNetworkReply::writeData( int &_cs, const char* data, qint64 len )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "writeData" );
  qint64 _writeData= (qint64)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _writeData;
  return (qint64)Function_10051( & _cs, _ro, & _obj, data, len );
}
bool DaoCxxVirt_QNetworkReply::atEnd( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::atEnd( _cs  );
}
qint64 DaoCxxVirt_QNetworkReply::bytesAvailable( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::bytesAvailable( _cs  );
}
qint64 DaoCxxVirt_QNetworkReply::bytesToWrite( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::bytesToWrite( _cs  );
}
bool DaoCxxVirt_QNetworkReply::canReadLine( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::canReadLine( _cs  );
}
bool DaoCxxVirt_QNetworkReply::open( int &_cs, QIODevice::OpenMode mode )
{
  return DaoCxxVirt_QIODevice::open( _cs, mode );
}
qint64 DaoCxxVirt_QNetworkReply::pos( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::pos( _cs  );
}
qint64 DaoCxxVirt_QNetworkReply::readData( int &_cs, char* data, qint64 maxlen )
{
  return DaoCxxVirt_QIODevice::readData( _cs, data, maxlen );
}
qint64 DaoCxxVirt_QNetworkReply::readLineData( int &_cs, char* data, qint64 maxlen )
{
  return DaoCxxVirt_QIODevice::readLineData( _cs, data, maxlen );
}
bool DaoCxxVirt_QNetworkReply::reset( int &_cs  )
{
  return DaoCxxVirt_QIODevice::reset( _cs  );
}
bool DaoCxxVirt_QNetworkReply::seek( int &_cs, qint64 pos )
{
  return DaoCxxVirt_QIODevice::seek( _cs, pos );
}
qint64 DaoCxxVirt_QNetworkReply::size( int &_cs  )const
{
  return DaoCxxVirt_QIODevice::size( _cs  );
}
bool DaoCxxVirt_QNetworkReply::waitForBytesWritten( int &_cs, int msecs )
{
  return DaoCxxVirt_QIODevice::waitForBytesWritten( _cs, msecs );
}
bool DaoCxxVirt_QNetworkReply::waitForReadyRead( int &_cs, int msecs )
{
  return DaoCxxVirt_QIODevice::waitForReadyRead( _cs, msecs );
}
void DaoCxx_QNetworkReply::abort(  )
{
  int _cs = 0;
  return DaoCxxVirt_QNetworkReply::abort( _cs  );
}
bool DaoCxx_QNetworkReply::atEnd(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "atEnd" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _atEnd = DaoCxxVirt_QNetworkReply::atEnd( _cs  );
	if( _cs ) return _atEnd;
  }
  return QIODevice::atEnd(  );
}
qint64 DaoCxx_QNetworkReply::bytesAvailable(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesAvailable" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesAvailable = DaoCxxVirt_QNetworkReply::bytesAvailable( _cs  );
	if( _cs ) return _bytesAvailable;
  }
  return QIODevice::bytesAvailable(  );
}
qint64 DaoCxx_QNetworkReply::bytesToWrite(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesToWrite" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesToWrite = DaoCxxVirt_QNetworkReply::bytesToWrite( _cs  );
	if( _cs ) return _bytesToWrite;
  }
  return QIODevice::bytesToWrite(  );
}
bool DaoCxx_QNetworkReply::canReadLine(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "canReadLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _canReadLine = DaoCxxVirt_QNetworkReply::canReadLine( _cs  );
	if( _cs ) return _canReadLine;
  }
  return QIODevice::canReadLine(  );
}
void DaoCxx_QNetworkReply::close(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "close" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkReply::close( _cs  );
	if( _cs ) return;
  }
  QNetworkReply::close(  );
}
void DaoCxx_QNetworkReply::ignoreSslErrors(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "ignoreSslErrors" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkReply::ignoreSslErrors( _cs  );
	if( _cs ) return;
  }
  QNetworkReply::ignoreSslErrors(  );
}
bool DaoCxx_QNetworkReply::isSequential(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "isSequential" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _isSequential = DaoCxxVirt_QNetworkReply::isSequential( _cs  );
	if( _cs ) return _isSequential;
  }
  return QNetworkReply::isSequential(  );
}
bool DaoCxx_QNetworkReply::open( QIODevice::OpenMode mode )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "open" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _open = DaoCxxVirt_QNetworkReply::open( _cs, mode );
	if( _cs ) return _open;
  }
  return QIODevice::open( mode );
}
qint64 DaoCxx_QNetworkReply::pos(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "pos" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _pos = DaoCxxVirt_QNetworkReply::pos( _cs  );
	if( _cs ) return _pos;
  }
  return QIODevice::pos(  );
}
qint64 DaoCxx_QNetworkReply::readData( char* data, qint64 maxlen )
{
  int _cs = 0;
  return DaoCxxVirt_QNetworkReply::readData( _cs, data, maxlen );
}
qint64 DaoCxx_QNetworkReply::readLineData( char* data, qint64 maxlen )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readLineData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _readLineData = DaoCxxVirt_QNetworkReply::readLineData( _cs, data, maxlen );
	if( _cs ) return _readLineData;
  }
  return QIODevice::readLineData( data, maxlen );
}
bool DaoCxx_QNetworkReply::reset(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "reset" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _reset = DaoCxxVirt_QNetworkReply::reset( _cs  );
	if( _cs ) return _reset;
  }
  return QIODevice::reset(  );
}
bool DaoCxx_QNetworkReply::seek( qint64 pos )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "seek" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _seek = DaoCxxVirt_QNetworkReply::seek( _cs, pos );
	if( _cs ) return _seek;
  }
  return QIODevice::seek( pos );
}
void DaoCxx_QNetworkReply::setReadBufferSize( qint64 size )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setReadBufferSize" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QNetworkReply::setReadBufferSize( _cs, size );
	if( _cs ) return;
  }
  QNetworkReply::setReadBufferSize( size );
}
qint64 DaoCxx_QNetworkReply::size(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "size" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _size = DaoCxxVirt_QNetworkReply::size( _cs  );
	if( _cs ) return _size;
  }
  return QIODevice::size(  );
}
bool DaoCxx_QNetworkReply::waitForBytesWritten( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForBytesWritten" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForBytesWritten = DaoCxxVirt_QNetworkReply::waitForBytesWritten( _cs, msecs );
	if( _cs ) return _waitForBytesWritten;
  }
  return QIODevice::waitForBytesWritten( msecs );
}
bool DaoCxx_QNetworkReply::waitForReadyRead( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForReadyRead" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForReadyRead = DaoCxxVirt_QNetworkReply::waitForReadyRead( _cs, msecs );
	if( _cs ) return _waitForReadyRead;
  }
  return QIODevice::waitForReadyRead( msecs );
}
qint64 DaoCxx_QNetworkReply::writeData( const char* data, qint64 len )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "writeData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _writeData = DaoCxxVirt_QNetworkReply::writeData( _cs, data, len );
	if( _cs ) return _writeData;
  }
  return QNetworkReply::writeData( data, len );
}




QNetworkRequest* DAO_DLL_QTNETWORK Dao_QNetworkRequest_New( const QNetworkRequest &other )
{
	QNetworkRequest *object = new QNetworkRequest( other );
	return object;
}
QNetworkRequest* DAO_DLL_QTNETWORK Dao_QNetworkRequest_New( const QUrl &url )
{
	QNetworkRequest *object = new QNetworkRequest( url );
	return object;
}


QSslCertificate* DAO_DLL_QTNETWORK Dao_QSslCertificate_New( QIODevice* device, QSsl::EncodingFormat format )
{
	QSslCertificate *object = new QSslCertificate( device, format );
	return object;
}
QSslCertificate* DAO_DLL_QTNETWORK Dao_QSslCertificate_New( const QByteArray &encoded, QSsl::EncodingFormat format )
{
	QSslCertificate *object = new QSslCertificate( encoded, format );
	return object;
}
QSslCertificate* DAO_DLL_QTNETWORK Dao_QSslCertificate_New( const QSslCertificate &other )
{
	QSslCertificate *object = new QSslCertificate( other );
	return object;
}


QSslCipher* DAO_DLL_QTNETWORK Dao_QSslCipher_New(  )
{
	QSslCipher *object = new QSslCipher(  );
	return object;
}
QSslCipher* DAO_DLL_QTNETWORK Dao_QSslCipher_New( const QSslCipher &other )
{
	QSslCipher *object = new QSslCipher( other );
	return object;
}
QSslCipher* DAO_DLL_QTNETWORK Dao_QSslCipher_New( const QString &name, QSsl::SslProtocol protocol )
{
	QSslCipher *object = new QSslCipher( name, protocol );
	return object;
}


QSslConfiguration* DAO_DLL_QTNETWORK Dao_QSslConfiguration_New(  )
{
	QSslConfiguration *object = new QSslConfiguration(  );
	return object;
}
QSslConfiguration* DAO_DLL_QTNETWORK Dao_QSslConfiguration_New( const QSslConfiguration &other )
{
	QSslConfiguration *object = new QSslConfiguration( other );
	return object;
}



QSslError* DAO_DLL_QTNETWORK Dao_QSslError_New(  )
{
	QSslError *object = new QSslError(  );
	return object;
}
QSslError* DAO_DLL_QTNETWORK Dao_QSslError_New( QSslError::SslError error )
{
	QSslError *object = new QSslError( error );
	return object;
}
QSslError* DAO_DLL_QTNETWORK Dao_QSslError_New( QSslError::SslError error, const QSslCertificate &certificate )
{
	QSslError *object = new QSslError( error, certificate );
	return object;
}
QSslError* DAO_DLL_QTNETWORK Dao_QSslError_New( const QSslError &other )
{
	QSslError *object = new QSslError( other );
	return object;
}


QSslKey* DAO_DLL_QTNETWORK Dao_QSslKey_New(  )
{
	QSslKey *object = new QSslKey(  );
	return object;
}
QSslKey* DAO_DLL_QTNETWORK Dao_QSslKey_New( QIODevice* device, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray &passPhrase )
{
	QSslKey *object = new QSslKey( device, algorithm, format, type, passPhrase );
	return object;
}
QSslKey* DAO_DLL_QTNETWORK Dao_QSslKey_New( const QByteArray &encoded, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray &passPhrase )
{
	QSslKey *object = new QSslKey( encoded, algorithm, format, type, passPhrase );
	return object;
}
QSslKey* DAO_DLL_QTNETWORK Dao_QSslKey_New( const QSslKey &other )
{
	QSslKey *object = new QSslKey( other );
	return object;
}

void DAO_DLL_QTNETWORK Dao_QTcpSocket_InitSS( QTcpSocket *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QTcpSocket *linker = new DaoSS_QTcpSocket();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QTcpSocket* DAO_DLL_QTNETWORK DaoCxx_QTcpSocket_New( QObject* parent )
{
	DaoCxx_QTcpSocket *self = new DaoCxx_QTcpSocket( parent );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QTcpSocket* DAO_DLL_QTNETWORK DaoCxx_QTcpSocket_New( QTcpSocketPrivate &dd, QObject* parent )
{
	DaoCxx_QTcpSocket *self = new DaoCxx_QTcpSocket( dd, parent );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QTcpSocket::DaoInitWrapper( QTcpSocket *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QAbstractSocket::DaoInitWrapper( s, d );
}
DaoCxx_QTcpSocket::~DaoCxx_QTcpSocket()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QTcpSocket::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QTcpSocket_Typer, this );
	DaoCxxVirt_QTcpSocket::DaoInitWrapper( this, cdata );
   DaoSS_QTcpSocket *linker = new DaoSS_QTcpSocket();
   setUserData( 0, linker );
   linker->Init( cdata );
}

void DAO_DLL_QTNETWORK Dao_QSslSocket_InitSS( QSslSocket *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QSslSocket *linker = new DaoSS_QSslSocket();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QSslSocket* DAO_DLL_QTNETWORK DaoCxx_QSslSocket_New( QObject* parent )
{
	DaoCxx_QSslSocket *self = new DaoCxx_QSslSocket( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QSslSocket::slot_startClientEncryption412( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_startClientEncryption412(  );
}
void DaoSS_QSslSocket::slot_startServerEncryption268( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_startServerEncryption268(  );
}
void DaoSS_QSslSocket::slot_ignoreSslErrors485( void*, void*, const DaoQtMessage &_msg )
{
  DValue **_p = (DValue**) _msg.p2;
  emit signal_ignoreSslErrors485(  );
}
void DaoSS_QSslSocket::slot_encrypted406(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_encrypted406( this, "encrypted()", _message );
}
void DaoSS_QSslSocket::slot_peerVerifyError253( const QSslError &error )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_WrapCData( dao_QSslError_Typer, (void*) & error );
  emit signal_peerVerifyError253( this, "peerVerifyError(const QSslError&)", _message );
}
void DaoSS_QSslSocket::slot_modeChanged648( QSslSocket::SslMode newMode )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewInteger( (int) newMode );
  emit signal_modeChanged648( this, "modeChanged(QSslSocket::SslMode)", _message );
}
void DaoSS_QSslSocket::slot_encryptedBytesWritten184( qint64 totalBytes )
{
  DaoQtMessage _message( 1 );
  assert( 1 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  _dp[0] = DValue_NewDouble( (double) totalBytes );
  emit signal_encryptedBytesWritten184( this, "encryptedBytesWritten(qint64)", _message );
}
void DaoCxxVirt_QSslSocket::DaoInitWrapper( QSslSocket *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QTcpSocket::DaoInitWrapper( s, d );
}
DaoCxx_QSslSocket::~DaoCxx_QSslSocket()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QSslSocket::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QSslSocket_Typer, this );
	DaoCxxVirt_QSslSocket::DaoInitWrapper( this, cdata );
   DaoSS_QSslSocket *linker = new DaoSS_QSslSocket();
   setUserData( 0, linker );
   linker->Init( cdata );
}
bool DaoCxx_QSslSocket::atEnd(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "atEnd" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _atEnd = DaoCxxVirt_QIODevice::atEnd( _cs  );
	if( _cs ) return _atEnd;
  }
  return QSslSocket::atEnd(  );
}
qint64 DaoCxx_QSslSocket::bytesAvailable(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesAvailable" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesAvailable = DaoCxxVirt_QIODevice::bytesAvailable( _cs  );
	if( _cs ) return _bytesAvailable;
  }
  return QSslSocket::bytesAvailable(  );
}
qint64 DaoCxx_QSslSocket::bytesToWrite(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "bytesToWrite" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _bytesToWrite = DaoCxxVirt_QIODevice::bytesToWrite( _cs  );
	if( _cs ) return _bytesToWrite;
  }
  return QSslSocket::bytesToWrite(  );
}
bool DaoCxx_QSslSocket::canReadLine(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "canReadLine" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _canReadLine = DaoCxxVirt_QIODevice::canReadLine( _cs  );
	if( _cs ) return _canReadLine;
  }
  return QSslSocket::canReadLine(  );
}
void DaoCxx_QSslSocket::close(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "close" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QIODevice::close( _cs  );
	if( _cs ) return;
  }
  QSslSocket::close(  );
}
qint64 DaoCxx_QSslSocket::readData( char* data, qint64 maxlen )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "readData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _readData = DaoCxxVirt_QIODevice::readData( _cs, data, maxlen );
	if( _cs ) return _readData;
  }
  return QSslSocket::readData( data, maxlen );
}
bool DaoCxx_QSslSocket::waitForBytesWritten( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForBytesWritten" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForBytesWritten = DaoCxxVirt_QIODevice::waitForBytesWritten( _cs, msecs );
	if( _cs ) return _waitForBytesWritten;
  }
  return QSslSocket::waitForBytesWritten( msecs );
}
bool DaoCxx_QSslSocket::waitForReadyRead( int msecs )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "waitForReadyRead" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _waitForReadyRead = DaoCxxVirt_QIODevice::waitForReadyRead( _cs, msecs );
	if( _cs ) return _waitForReadyRead;
  }
  return QSslSocket::waitForReadyRead( msecs );
}
qint64 DaoCxx_QSslSocket::writeData( const char* data, qint64 len )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "writeData" );
  if( _ro && _obj.t == DAO_OBJECT ){
    qint64 _writeData = DaoCxxVirt_QIODevice::writeData( _cs, data, len );
	if( _cs ) return _writeData;
  }
  return QSslSocket::writeData( data, len );
}

void DAO_DLL_QTNETWORK Dao_QTcpServer_InitSS( QTcpServer *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QTcpServer *linker = new DaoSS_QTcpServer();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QTcpServer* DAO_DLL_QTNETWORK DaoCxx_QTcpServer_New( QObject* parent )
{
	DaoCxx_QTcpServer *self = new DaoCxx_QTcpServer( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoSS_QTcpServer::slot_newConnection771(  )
{
  DaoQtMessage _message( 0 );
  assert( 0 <= DAOQT_MAX_VALUE );
  DValue *_dp = _message.p1;
  emit signal_newConnection771( this, "newConnection()", _message );
}
void DaoCxxVirt_QTcpServer::DaoInitWrapper( QTcpServer *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QObject::DaoInitWrapper( s, d );
}
DaoCxx_QTcpServer::~DaoCxx_QTcpServer()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QTcpServer::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QTcpServer_Typer, this );
	DaoCxxVirt_QTcpServer::DaoInitWrapper( this, cdata );
   DaoSS_QTcpServer *linker = new DaoSS_QTcpServer();
   setUserData( 0, linker );
   linker->Init( cdata );
}
bool DaoCxxVirt_QTcpServer::hasPendingConnections( int &_cs  )const
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "hasPendingConnections" );
  bool _hasPendingConnections= (bool)0;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _hasPendingConnections;
  return (bool)Function_10018( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QTcpServer::incomingConnection( int &_cs, int handle )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "incomingConnection" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_1001d( & _cs, _ro, & _obj, handle );
}
QTcpSocket* DaoCxxVirt_QTcpServer::nextPendingConnection( int &_cs  )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "nextPendingConnection" );
  QTcpSocket* _nextPendingConnection = NULL;
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return _nextPendingConnection;
  return (QTcpSocket*)Function_104b1( & _cs, _ro, & _obj );
}
void DaoCxxVirt_QTcpServer::childEvent( int &_cs, QChildEvent* _cp0 )
{
   DaoCxxVirt_QObject::childEvent( _cs, _cp0 );
}
void DaoCxxVirt_QTcpServer::connectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::connectNotify( _cs, signal );
}
void DaoCxxVirt_QTcpServer::customEvent( int &_cs, QEvent* _cp0 )
{
   DaoCxxVirt_QObject::customEvent( _cs, _cp0 );
}
void DaoCxxVirt_QTcpServer::disconnectNotify( int &_cs, const char* signal )
{
   DaoCxxVirt_QObject::disconnectNotify( _cs, signal );
}
bool DaoCxxVirt_QTcpServer::event( int &_cs, QEvent* _cp0 )
{
  return DaoCxxVirt_QObject::event( _cs, _cp0 );
}
bool DaoCxxVirt_QTcpServer::eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 )
{
  return DaoCxxVirt_QObject::eventFilter( _cs, _cp0, _cp1 );
}
void DaoCxxVirt_QTcpServer::timerEvent( int &_cs, QTimerEvent* _cp0 )
{
   DaoCxxVirt_QObject::timerEvent( _cs, _cp0 );
}
void DaoCxx_QTcpServer::childEvent( QChildEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "childEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QTcpServer::childEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::childEvent( _cp0 );
}
void DaoCxx_QTcpServer::connectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "connectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QTcpServer::connectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::connectNotify( signal );
}
void DaoCxx_QTcpServer::customEvent( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "customEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QTcpServer::customEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::customEvent( _cp0 );
}
void DaoCxx_QTcpServer::disconnectNotify( const char* signal )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "disconnectNotify" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QTcpServer::disconnectNotify( _cs, signal );
	if( _cs ) return;
  }
  QObject::disconnectNotify( signal );
}
bool DaoCxx_QTcpServer::event( QEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "event" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _event = DaoCxxVirt_QTcpServer::event( _cs, _cp0 );
	if( _cs ) return _event;
  }
  return QObject::event( _cp0 );
}
bool DaoCxx_QTcpServer::eventFilter( QObject* _cp0, QEvent* _cp1 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "eventFilter" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _eventFilter = DaoCxxVirt_QTcpServer::eventFilter( _cs, _cp0, _cp1 );
	if( _cs ) return _eventFilter;
  }
  return QObject::eventFilter( _cp0, _cp1 );
}
bool DaoCxx_QTcpServer::hasPendingConnections(  )const
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "hasPendingConnections" );
  if( _ro && _obj.t == DAO_OBJECT ){
    bool _hasPendingConnections = DaoCxxVirt_QTcpServer::hasPendingConnections( _cs  );
	if( _cs ) return _hasPendingConnections;
  }
  return QTcpServer::hasPendingConnections(  );
}
void DaoCxx_QTcpServer::incomingConnection( int handle )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "incomingConnection" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QTcpServer::incomingConnection( _cs, handle );
	if( _cs ) return;
  }
  QTcpServer::incomingConnection( handle );
}
QTcpSocket* DaoCxx_QTcpServer::nextPendingConnection(  )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "nextPendingConnection" );
  if( _ro && _obj.t == DAO_OBJECT ){
    QTcpSocket* _nextPendingConnection = DaoCxxVirt_QTcpServer::nextPendingConnection( _cs  );
	if( _cs ) return _nextPendingConnection;
  }
  return QTcpServer::nextPendingConnection(  );
}
void DaoCxx_QTcpServer::timerEvent( QTimerEvent* _cp0 )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "timerEvent" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QTcpServer::timerEvent( _cs, _cp0 );
	if( _cs ) return;
  }
  QObject::timerEvent( _cp0 );
}


void DAO_DLL_QTNETWORK Dao_QUdpSocket_InitSS( QUdpSocket *p )
{
   if( p->userData(0) == NULL ){
		DaoSS_QUdpSocket *linker = new DaoSS_QUdpSocket();
		p->setUserData( 0, linker );
		linker->Init( NULL );
	}
}
DaoCxx_QUdpSocket* DAO_DLL_QTNETWORK DaoCxx_QUdpSocket_New( QObject* parent )
{
	DaoCxx_QUdpSocket *self = new DaoCxx_QUdpSocket( parent );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QUdpSocket::DaoInitWrapper( QUdpSocket *s, DaoCData *d )
{
	self = s;
	cdata = d;
	DaoCxxVirt_QAbstractSocket::DaoInitWrapper( s, d );
}
DaoCxx_QUdpSocket::~DaoCxx_QUdpSocket()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QUdpSocket::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QUdpSocket_Typer, this );
	DaoCxxVirt_QUdpSocket::DaoInitWrapper( this, cdata );
   DaoSS_QUdpSocket *linker = new DaoSS_QUdpSocket();
   setUserData( 0, linker );
   linker->Init( cdata );
}


DaoCxx_QUrlInfo* DAO_DLL_QTNETWORK DaoCxx_QUrlInfo_New(  )
{
	DaoCxx_QUrlInfo *self = new DaoCxx_QUrlInfo(  );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QUrlInfo* DAO_DLL_QTNETWORK DaoCxx_QUrlInfo_New( const QString &name, int permissions, const QString &owner, const QString &group, qint64 size, const QDateTime &lastModified, const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable )
{
	DaoCxx_QUrlInfo *self = new DaoCxx_QUrlInfo( name, permissions, owner, group, size, lastModified, lastRead, isDir, isFile, isSymLink, isWritable, isReadable, isExecutable );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QUrlInfo* DAO_DLL_QTNETWORK DaoCxx_QUrlInfo_New( const QUrl &url, int permissions, const QString &owner, const QString &group, qint64 size, const QDateTime &lastModified, const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable )
{
	DaoCxx_QUrlInfo *self = new DaoCxx_QUrlInfo( url, permissions, owner, group, size, lastModified, lastRead, isDir, isFile, isSymLink, isWritable, isReadable, isExecutable );
	self->DaoInitWrapper();
	return self;
}
DaoCxx_QUrlInfo* DAO_DLL_QTNETWORK DaoCxx_QUrlInfo_New( const QUrlInfo &ui )
{
	DaoCxx_QUrlInfo *self = new DaoCxx_QUrlInfo( ui );
	self->DaoInitWrapper();
	return self;
}
void DaoCxxVirt_QUrlInfo::DaoInitWrapper( QUrlInfo *s, DaoCData *d )
{
	self = s;
	cdata = d;

}
DaoCxx_QUrlInfo::~DaoCxx_QUrlInfo()
{
	if( cdata ){
		DaoCData_SetData( cdata, NULL );
		DaoCData_SetExtReference( cdata, 0 );
	} 
}
void DaoCxx_QUrlInfo::DaoInitWrapper()
{
	cdata = DaoCData_New( dao_QUrlInfo_Typer, this );
	DaoCxxVirt_QUrlInfo::DaoInitWrapper( this, cdata );
}
QUrlInfo* DAO_DLL_QTNETWORK Dao_QUrlInfo_Copy( const QUrlInfo &p )
{
	QUrlInfo *object = new QUrlInfo( p );
	return object;
}
void DaoCxxVirt_QUrlInfo::setDir( int &_cs, bool b )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setDir" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10030( & _cs, _ro, & _obj, b );
}
void DaoCxxVirt_QUrlInfo::setFile( int &_cs, bool b )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setFile" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10030( & _cs, _ro, & _obj, b );
}
void DaoCxxVirt_QUrlInfo::setGroup( int &_cs, const QString &s )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setGroup" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10017( & _cs, _ro, & _obj, s );
}
void DaoCxxVirt_QUrlInfo::setLastModified( int &_cs, const QDateTime &dt )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setLastModified" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10311( & _cs, _ro, & _obj, dt );
}
void DaoCxxVirt_QUrlInfo::setName( int &_cs, const QString &name )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setName" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10017( & _cs, _ro, & _obj, name );
}
void DaoCxxVirt_QUrlInfo::setOwner( int &_cs, const QString &s )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setOwner" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10017( & _cs, _ro, & _obj, s );
}
void DaoCxxVirt_QUrlInfo::setPermissions( int &_cs, int p )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setPermissions" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_1001d( & _cs, _ro, & _obj, p );
}
void DaoCxxVirt_QUrlInfo::setReadable( int &_cs, bool b )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setReadable" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10030( & _cs, _ro, & _obj, b );
}
void DaoCxxVirt_QUrlInfo::setSize( int &_cs, qint64 size )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setSize" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_1009f( & _cs, _ro, & _obj, size );
}
void DaoCxxVirt_QUrlInfo::setSymLink( int &_cs, bool b )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setSymLink" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10030( & _cs, _ro, & _obj, b );
}
void DaoCxxVirt_QUrlInfo::setWritable( int &_cs, bool b )
{
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setWritable" );
  if( _ro ==NULL || _obj.t != DAO_OBJECT ) return;
  Function_10030( & _cs, _ro, & _obj, b );
}
void DaoCxx_QUrlInfo::setDir( bool b )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setDir" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setDir( _cs, b );
	if( _cs ) return;
  }
  QUrlInfo::setDir( b );
}
void DaoCxx_QUrlInfo::setFile( bool b )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setFile" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setFile( _cs, b );
	if( _cs ) return;
  }
  QUrlInfo::setFile( b );
}
void DaoCxx_QUrlInfo::setGroup( const QString &s )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setGroup" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setGroup( _cs, s );
	if( _cs ) return;
  }
  QUrlInfo::setGroup( s );
}
void DaoCxx_QUrlInfo::setLastModified( const QDateTime &dt )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setLastModified" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setLastModified( _cs, dt );
	if( _cs ) return;
  }
  QUrlInfo::setLastModified( dt );
}
void DaoCxx_QUrlInfo::setName( const QString &name )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setName" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setName( _cs, name );
	if( _cs ) return;
  }
  QUrlInfo::setName( name );
}
void DaoCxx_QUrlInfo::setOwner( const QString &s )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setOwner" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setOwner( _cs, s );
	if( _cs ) return;
  }
  QUrlInfo::setOwner( s );
}
void DaoCxx_QUrlInfo::setPermissions( int p )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setPermissions" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setPermissions( _cs, p );
	if( _cs ) return;
  }
  QUrlInfo::setPermissions( p );
}
void DaoCxx_QUrlInfo::setReadable( bool b )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setReadable" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setReadable( _cs, b );
	if( _cs ) return;
  }
  QUrlInfo::setReadable( b );
}
void DaoCxx_QUrlInfo::setSize( qint64 size )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setSize" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setSize( _cs, size );
	if( _cs ) return;
  }
  QUrlInfo::setSize( size );
}
void DaoCxx_QUrlInfo::setSymLink( bool b )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setSymLink" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setSymLink( _cs, b );
	if( _cs ) return;
  }
  QUrlInfo::setSymLink( b );
}
void DaoCxx_QUrlInfo::setWritable( bool b )
{
  int _cs = 0;
  DValue _obj = {0,0,0,0,{0}};
  DaoMethod *_ro = Dao_Get_Object_Method( cdata, & _obj, "setWritable" );
  if( _ro && _obj.t == DAO_OBJECT ){
    DaoCxxVirt_QUrlInfo::setWritable( _cs, b );
	if( _cs ) return;
  }
  QUrlInfo::setWritable( b );
}















